diff --git a/src/Makefile.am b/src/Makefile.am
index 1467a26cba53..7fa3738be100 100644
--- a/src/Makefile.am
+++ b/src/Makefile.am
@@ -212,6 +212,7 @@ BITCOIN_CORE_H = \
   llmq/snapshot.h \
   llmq/signing.h \
   llmq/signing_shares.h \
+  llmq/complex_utils.h \
   llmq/utils.h \
   llmq/params.h \
   logging.h \
@@ -292,6 +293,7 @@ BITCOIN_CORE_H = \
   util/check.h \
   util/error.h \
   util/fees.h \
+  util/hexstr.h \
   util/irange.h \
   util/spanparsing.h \
   util/system.h \
@@ -402,6 +404,7 @@ libdash_server_a_SOURCES = \
   llmq/snapshot.cpp \
   llmq/signing.cpp \
   llmq/signing_shares.cpp \
+  llmq/complex_utils.cpp \
   llmq/utils.cpp \
   mapport.cpp \
   masternode/node.cpp \
@@ -700,6 +703,7 @@ libdash_util_a_SOURCES = \
   util/error.cpp \
   util/fees.cpp \
   util/getuniquepath.cpp \
+  util/hexstr.cpp \
   util/system.cpp \
   util/asmap.cpp \
   util/moneystr.cpp \
diff --git a/src/bloom.cpp b/src/bloom.cpp
index b409b007b7ae..5d67a8dfa87a 100644
--- a/src/bloom.cpp
+++ b/src/bloom.cpp
@@ -13,6 +13,7 @@
 #include <script/standard.h>
 #include <random.h>
 #include <streams.h>
+#include <logging.h>
 
 #include <math.h>
 #include <stdlib.h>
diff --git a/src/evo/cbtx.cpp b/src/evo/cbtx.cpp
index b69d4339966c..2b3bb3be2a62 100644
--- a/src/evo/cbtx.cpp
+++ b/src/evo/cbtx.cpp
@@ -6,6 +6,7 @@
 #include <evo/deterministicmns.h>
 #include <llmq/blockprocessor.h>
 #include <llmq/commitment.h>
+#include <llmq/utils.h>
 #include <evo/simplifiedmns.h>
 #include <evo/specialtx.h>
 #include <consensus/validation.h>
@@ -13,6 +14,8 @@
 #include <chain.h>
 #include <chainparams.h>
 #include <consensus/merkle.h>
+#include <util/time.h>
+#include <logging.h>
 
 bool CheckCbTx(const CTransaction& tx, const CBlockIndex* pindexPrev, CValidationState& state)
 {
diff --git a/src/evo/deterministicmns.cpp b/src/evo/deterministicmns.cpp
index aba638335ecb..4765563a6eac 100644
--- a/src/evo/deterministicmns.cpp
+++ b/src/evo/deterministicmns.cpp
@@ -6,8 +6,11 @@
 #include <evo/dmnstate.h>
 #include <evo/specialtx.h>
 #include <evo/simplifiedmns.h>
+#include <evo/evodb.h>
 #include <llmq/commitment.h>
 #include <llmq/utils.h>
+#include <llmq/complex_utils.h>
+#include <llmq/params.h>
 #include <evo/providertx.h>
 
 #include <base58.h>
@@ -876,7 +879,7 @@ void CDeterministicMNManager::HandleQuorumCommitment(const llmq::CFinalCommitmen
 {
     // The commitment has already been validated at this point, so it's safe to use members of it
 
-    auto members = llmq::CLLMQUtils::GetAllQuorumMembers(qc.llmqType, pQuorumBaseBlockIndex);
+    auto members = llmq::CLLMQComplexUtils::GetAllQuorumMembers(qc.llmqType, pQuorumBaseBlockIndex);
 
     for (size_t i = 0; i < members.size(); i++) {
         if (!mnList.HasMN(members[i]->proTxHash)) {
diff --git a/src/evo/deterministicmns.h b/src/evo/deterministicmns.h
index 8281c832e25a..0cdf05ba5488 100644
--- a/src/evo/deterministicmns.h
+++ b/src/evo/deterministicmns.h
@@ -10,7 +10,6 @@
 #include <arith_uint256.h>
 #include <crypto/common.h>
 #include <consensus/params.h>
-#include <evo/evodb.h>
 #include <evo/providertx.h>
 #include <saltedhasher.h>
 #include <scheduler.h>
@@ -29,6 +28,9 @@ class CSimplifiedMNListDiff;
 
 extern CCriticalSection cs_main;
 
+class CEvoDB;
+class CDBBatch;
+
 namespace llmq
 {
     class CFinalCommitment;
diff --git a/src/evo/mnhftx.cpp b/src/evo/mnhftx.cpp
index f753ae5d840a..1ce091a0f0df 100644
--- a/src/evo/mnhftx.cpp
+++ b/src/evo/mnhftx.cpp
@@ -7,6 +7,7 @@
 #include <evo/specialtx.h>
 #include <llmq/commitment.h>
 #include <llmq/signing.h>
+#include <llmq/utils.h>
 
 #include <chain.h>
 #include <chainparams.h>
diff --git a/src/init.cpp b/src/init.cpp
index a1a8ce2693d0..eaafc847fa47 100644
--- a/src/init.cpp
+++ b/src/init.cpp
@@ -80,6 +80,7 @@
 #include <walletinitinterface.h>
 
 #include <evo/deterministicmns.h>
+#include <evo/evodb.h>
 #include <llmq/blockprocessor.h>
 #include <llmq/init.h>
 #include <llmq/quorums.h>
diff --git a/src/llmq/blockprocessor.cpp b/src/llmq/blockprocessor.cpp
index be5132cb50d4..a325d83e9824 100644
--- a/src/llmq/blockprocessor.cpp
+++ b/src/llmq/blockprocessor.cpp
@@ -4,6 +4,8 @@
 
 #include <llmq/blockprocessor.h>
 #include <llmq/commitment.h>
+#include <llmq/utils.h>
+#include <llmq/complex_utils.h>
 
 #include <evo/evodb.h>
 #include <evo/specialtx.h>
@@ -37,7 +39,7 @@ static const std::string DB_BEST_BLOCK_UPGRADE = "q_bbu2";
 CQuorumBlockProcessor::CQuorumBlockProcessor(CEvoDB &_evoDb, CConnman& _connman) :
     evoDb(_evoDb), connman(_connman)
 {
-    CLLMQUtils::InitQuorumsCache(mapHasMinedCommitmentCache);
+    CLLMQComplexUtils::InitQuorumsCache(mapHasMinedCommitmentCache);
 }
 
 void CQuorumBlockProcessor::ProcessMessage(CNode* pfrom, const std::string& msg_type, CDataStream& vRecv)
@@ -130,7 +132,7 @@ bool CQuorumBlockProcessor::ProcessBlock(const CBlock& block, const CBlockIndex*
         return true;
     }
 
-    llmq::CLLMQUtils::PreComputeQuorumMembers(pindex);
+    llmq::CLLMQComplexUtils::PreComputeQuorumMembers(pindex);
 
     std::multimap<Consensus::LLMQType, CFinalCommitment> qcs;
     if (!GetCommitmentsFromBlock(block, pindex, qcs, state)) {
@@ -143,7 +145,7 @@ bool CQuorumBlockProcessor::ProcessBlock(const CBlock& block, const CBlockIndex*
     // until the first non-null commitment has been mined. After the non-null commitment, no other commitments are
     // allowed, including null commitments.
     // Note: must only check quorums that were enabled at the _previous_ block height to match mining logic
-    for (const Consensus::LLMQParams& params : CLLMQUtils::GetEnabledQuorumParams(pindex->pprev)) {
+    for (const Consensus::LLMQParams& params : CLLMQComplexUtils::GetEnabledQuorumParams(pindex->pprev)) {
         // skip these checks when replaying blocks after the crash
         if (::ChainActive().Tip() == nullptr) {
             break;
diff --git a/src/llmq/commitment.cpp b/src/llmq/commitment.cpp
index a01f96c6e163..22d917640eaf 100644
--- a/src/llmq/commitment.cpp
+++ b/src/llmq/commitment.cpp
@@ -4,6 +4,8 @@
 
 #include <llmq/commitment.h>
 
+#include <llmq/utils.h>
+#include <llmq/complex_utils.h>
 #include <evo/deterministicmns.h>
 #include <evo/specialtx.h>
 
@@ -79,7 +81,7 @@ bool CFinalCommitment::Verify(const CBlockIndex* pQuorumBaseBlockIndex, bool che
         LogPrintfFinalCommitment("q[%s] invalid vvecSig\n");
         return false;
     }
-    auto members = CLLMQUtils::GetAllQuorumMembers(llmqType, pQuorumBaseBlockIndex);
+    auto members = CLLMQComplexUtils::GetAllQuorumMembers(llmqType, pQuorumBaseBlockIndex);
     std::stringstream ss;
     for (const auto i : irange::range(llmq_params.size)) {
         ss << "v[" << i << "]=" << validMembers[i];
@@ -160,6 +162,23 @@ bool CFinalCommitment::VerifySizes(const Consensus::LLMQParams& params) const
     return true;
 }
 
+//void CFinalCommitment::ToJson(UniValue& obj) const
+//{
+//    obj.setObject();
+//    obj.pushKV("version", (int)nVersion);
+//    obj.pushKV("llmqType", (int)llmqType);
+//    obj.pushKV("quorumHash", quorumHash.ToString());
+//    obj.pushKV("quorumIndex", quorumIndex);
+//    obj.pushKV("signersCount", CountSigners());
+//    obj.pushKV("signers", CLLMQUtils::ToHexStr(signers));
+//    obj.pushKV("validMembersCount", CountValidMembers());
+//    obj.pushKV("validMembers", CLLMQUtils::ToHexStr(validMembers));
+//    obj.pushKV("quorumPublicKey", quorumPublicKey.ToString());
+//    obj.pushKV("quorumVvecHash", quorumVvecHash.ToString());
+//    obj.pushKV("quorumSig", quorumSig.ToString());
+//    obj.pushKV("membersSig", membersSig.ToString());
+//}
+//
 bool CheckLLMQCommitment(const CTransaction& tx, const CBlockIndex* pindexPrev, CValidationState& state)
 {
     CFinalCommitmentTxPayload qcTx;
@@ -217,4 +236,15 @@ bool CheckLLMQCommitment(const CTransaction& tx, const CBlockIndex* pindexPrev,
     return true;
 }
 
+//void CFinalCommitmentTxPayload::ToJson(UniValue& obj) const
+//{
+//    obj.setObject();
+//    obj.pushKV("version", int(nVersion));
+//    obj.pushKV("height", int(nHeight));
+//
+//    UniValue qcObj;
+//    commitment.ToJson(qcObj);
+//    obj.pushKV("commitment", qcObj);
+//}
+
 } // namespace llmq
diff --git a/src/llmq/commitment.h b/src/llmq/commitment.h
index 3e37a22d5839..9bbb03c8fdfe 100644
--- a/src/llmq/commitment.h
+++ b/src/llmq/commitment.h
@@ -5,13 +5,18 @@
 #ifndef BITCOIN_LLMQ_COMMITMENT_H
 #define BITCOIN_LLMQ_COMMITMENT_H
 
-#include <llmq/utils.h>
 #include <bls/bls.h>
+#include <llmq/params.h>
+#include <primitives/transaction.h>
+#include <util/hexstr.h>
 
 #include <univalue.h>
 
 class CValidationState;
 
+class CBlockIndex;
+class CTransaction;
+
 namespace llmq
 {
 
@@ -105,9 +110,9 @@ class CFinalCommitment
         obj.pushKV("quorumHash", quorumHash.ToString());
         obj.pushKV("quorumIndex", quorumIndex);
         obj.pushKV("signersCount", CountSigners());
-        obj.pushKV("signers", CLLMQUtils::ToHexStr(signers));
+        obj.pushKV("signers", BitsToHexStr(signers));
         obj.pushKV("validMembersCount", CountValidMembers());
-        obj.pushKV("validMembers", CLLMQUtils::ToHexStr(validMembers));
+        obj.pushKV("validMembers", BitsToHexStr(validMembers));
         obj.pushKV("quorumPublicKey", quorumPublicKey.ToString());
         obj.pushKV("quorumVvecHash", quorumVvecHash.ToString());
         obj.pushKV("quorumSig", quorumSig.ToString());
@@ -127,6 +132,8 @@ class CFinalCommitmentTxPayload
     CFinalCommitment commitment;
 
 public:
+//    void ToJson(UniValue& obj) const;
+
     SERIALIZE_METHODS(CFinalCommitmentTxPayload, obj)
     {
         READWRITE(obj.nVersion, obj.nHeight, obj.commitment);
diff --git a/src/llmq/complex_utils.cpp b/src/llmq/complex_utils.cpp
new file mode 100644
index 000000000000..843d83a0c696
--- /dev/null
+++ b/src/llmq/complex_utils.cpp
@@ -0,0 +1,733 @@
+// Copyright (c) 2018-2021 The Dash Core developers
+// Distributed under the MIT software license, see the accompanying
+// file COPYING or http://www.opensource.org/licenses/mit-license.php.
+
+#include <llmq/complex_utils.h>
+#include <llmq/utils.h>
+
+#include <llmq/quorums.h>
+
+#include <llmq/commitment.h>
+#include <llmq/snapshot.h>
+
+#include <chainparams.h>
+#include <evo/deterministicmns.h>
+#include <masternode/meta.h>
+#include <net.h>
+#include <timedata.h>
+#include <util/ranges.h>
+#include <versionbits.h>
+#include <chain.h>
+#include <uint256.h>
+#include <hash.h>
+#include <logging.h>
+
+#include <vector>
+#include <set>
+#include <optional>
+
+namespace llmq
+{
+
+std::vector<CDeterministicMNCPtr> CLLMQComplexUtils::ComputeQuorumMembers(Consensus::LLMQType llmqType, const CBlockIndex* pQuorumBaseBlockIndex)
+{
+    auto allMns = deterministicMNManager->GetListForBlock(pQuorumBaseBlockIndex);
+    auto modifier = ::SerializeHash(std::make_pair(llmqType, pQuorumBaseBlockIndex->GetBlockHash()));
+    return allMns.CalculateQuorum(GetLLMQParams(llmqType).size, modifier);
+}
+
+std::vector<std::vector<CDeterministicMNCPtr>> CLLMQComplexUtils::ComputeQuorumMembersByQuarterRotation(Consensus::LLMQType llmqType, const CBlockIndex* pCycleQuorumBaseBlockIndex)
+{
+    const Consensus::LLMQParams& llmqParams = GetLLMQParams(llmqType);
+
+    const int cycleLength = llmqParams.dkgInterval;
+    assert(pCycleQuorumBaseBlockIndex->nHeight % cycleLength == 0);
+
+    const CBlockIndex* pBlockHMinusCIndex = pCycleQuorumBaseBlockIndex->GetAncestor(pCycleQuorumBaseBlockIndex->nHeight - cycleLength);
+    const CBlockIndex* pBlockHMinus2CIndex = pCycleQuorumBaseBlockIndex->GetAncestor(pCycleQuorumBaseBlockIndex->nHeight - 2 * cycleLength);
+    const CBlockIndex* pBlockHMinus3CIndex = pCycleQuorumBaseBlockIndex->GetAncestor(pCycleQuorumBaseBlockIndex->nHeight - 3 * cycleLength);
+    LOCK(deterministicMNManager->cs);
+    const CBlockIndex* pWorkBlockIndex = pCycleQuorumBaseBlockIndex->GetAncestor(pCycleQuorumBaseBlockIndex->nHeight - 8);
+    auto allMns = deterministicMNManager->GetListForBlock(pWorkBlockIndex);
+    LogPrint(BCLog::LLMQ, "CLLMQComplexUtils::ComputeQuorumMembersByQuarterRotation llmqType[%d] nHeight[%d] allMns[%d]\n", static_cast<int>(llmqType), pCycleQuorumBaseBlockIndex->nHeight, allMns.GetValidMNsCount());
+
+    PreviousQuorumQuarters previousQuarters = GetPreviousQuorumQuarterMembers(llmqParams, pBlockHMinusCIndex, pBlockHMinus2CIndex, pBlockHMinus3CIndex, pCycleQuorumBaseBlockIndex->nHeight);
+
+    auto nQuorums = size_t(llmqParams.signingActiveQuorumCount);
+    std::vector<std::vector<CDeterministicMNCPtr>> quorumMembers(nQuorums);
+
+    auto newQuarterMembers = CLLMQComplexUtils::BuildNewQuorumQuarterMembers(llmqParams, pCycleQuorumBaseBlockIndex, previousQuarters);
+    //TODO Check if it is triggered from outside (P2P, block validation). Throwing an exception is probably a wiser choice
+    //assert (!newQuarterMembers.empty());
+
+    for (auto i = 0; i < nQuorums; ++i) {
+        std::stringstream ss;
+
+        ss << " 3Cmns[";
+        for (auto& m : previousQuarters.quarterHMinus3C[i]) {
+            ss << m->proTxHash.ToString().substr(0, 4) << " | ";
+        }
+        ss << " ] 2Cmns[";
+        for (auto& m : previousQuarters.quarterHMinus2C[i]) {
+            ss << m->proTxHash.ToString().substr(0, 4) << " | ";
+        }
+        ss << " ] Cmns[";
+        for (auto& m : previousQuarters.quarterHMinusC[i]) {
+            ss << m->proTxHash.ToString().substr(0, 4) << " | ";
+        }
+        ss << " ] new[";
+        for (auto& m : newQuarterMembers[i]) {
+            ss << m->proTxHash.ToString().substr(0, 4) << " | ";
+        }
+        ss << " ]";
+        LogPrint(BCLog::LLMQ, "QuarterComposition h[%d] i[%d]:%s\n", pCycleQuorumBaseBlockIndex->nHeight, i, ss.str());
+    }
+
+    for (auto i = 0; i < nQuorums; ++i) {
+        for (auto& m : previousQuarters.quarterHMinus3C[i]) {
+            quorumMembers[i].push_back(std::move(m));
+        }
+        for (auto& m : previousQuarters.quarterHMinus2C[i]) {
+            quorumMembers[i].push_back(std::move(m));
+        }
+        for (auto& m : previousQuarters.quarterHMinusC[i]) {
+            quorumMembers[i].push_back(std::move(m));
+        }
+        for (auto& m : newQuarterMembers[i]) {
+            quorumMembers[i].push_back(std::move(m));
+        }
+
+        std::stringstream ss;
+        ss << " [";
+        for (auto& m : quorumMembers[i]) {
+            ss << m->proTxHash.ToString().substr(0, 4) << " | ";
+        }
+        ss << "]";
+        LogPrint(BCLog::LLMQ, "QuorumComposition h[%d] i[%d]:%s\n", pCycleQuorumBaseBlockIndex->nHeight, i, ss.str());
+    }
+
+    return quorumMembers;
+}
+
+PreviousQuorumQuarters CLLMQComplexUtils::GetPreviousQuorumQuarterMembers(const Consensus::LLMQParams& llmqParams, const CBlockIndex* pBlockHMinusCIndex, const CBlockIndex* pBlockHMinus2CIndex, const CBlockIndex* pBlockHMinus3CIndex, int nHeight)
+{
+    auto nQuorums = size_t(llmqParams.signingActiveQuorumCount);
+    PreviousQuorumQuarters quarters(nQuorums);
+
+    std::optional<llmq::CQuorumSnapshot> quSnapshotHMinusC = quorumSnapshotManager->GetSnapshotForBlock(llmqParams.type, pBlockHMinusCIndex);
+    if (quSnapshotHMinusC.has_value()) {
+        quarters.quarterHMinusC = CLLMQComplexUtils::GetQuorumQuarterMembersBySnapshot(llmqParams, pBlockHMinusCIndex, quSnapshotHMinusC.value(), nHeight);
+        //TODO Check if it is triggered from outside (P2P, block validation). Throwing an exception is probably a wiser choice
+        //assert (!quarterHMinusC.empty());
+
+        std::optional<llmq::CQuorumSnapshot> quSnapshotHMinus2C = quorumSnapshotManager->GetSnapshotForBlock(llmqParams.type, pBlockHMinus2CIndex);
+        if (quSnapshotHMinus2C.has_value()) {
+            quarters.quarterHMinus2C = CLLMQComplexUtils::GetQuorumQuarterMembersBySnapshot(llmqParams, pBlockHMinus2CIndex, quSnapshotHMinus2C.value(), nHeight);
+            //TODO Check if it is triggered from outside (P2P, block validation). Throwing an exception is probably a wiser choice
+            //assert (!quarterHMinusC.empty());
+
+            std::optional<llmq::CQuorumSnapshot> quSnapshotHMinus3C = quorumSnapshotManager->GetSnapshotForBlock(llmqParams.type, pBlockHMinus3CIndex);
+            if (quSnapshotHMinus3C.has_value()) {
+                quarters.quarterHMinus3C = CLLMQComplexUtils::GetQuorumQuarterMembersBySnapshot(llmqParams, pBlockHMinus3CIndex, quSnapshotHMinus3C.value(), nHeight);
+                //TODO Check if it is triggered from outside (P2P, block validation). Throwing an exception is probably a wiser choice
+                //assert (!quarterHMinusC.empty());
+            }
+        }
+    }
+
+    return quarters;
+}
+
+std::vector<std::vector<CDeterministicMNCPtr>> CLLMQComplexUtils::BuildNewQuorumQuarterMembers(const Consensus::LLMQParams& llmqParams, const CBlockIndex* pQuorumBaseBlockIndex, const PreviousQuorumQuarters& previousQuarters)
+{
+    auto nQuorums = size_t(llmqParams.signingActiveQuorumCount);
+    std::vector<std::vector<CDeterministicMNCPtr>> quarterQuorumMembers(nQuorums);
+
+    auto quorumSize = size_t(llmqParams.size);
+    auto quarterSize = quorumSize / 4;
+    const CBlockIndex* pWorkBlockIndex = pQuorumBaseBlockIndex->GetAncestor(pQuorumBaseBlockIndex->nHeight - 8);
+    auto modifier = ::SerializeHash(std::make_pair(llmqParams.type, pWorkBlockIndex->GetBlockHash()));
+
+    LOCK(deterministicMNManager->cs);
+    auto allMns = deterministicMNManager->GetListForBlock(pWorkBlockIndex);
+
+    if (allMns.GetValidMNsCount() < quarterSize) return quarterQuorumMembers;
+
+    auto MnsUsedAtH = CDeterministicMNList();
+    auto MnsNotUsedAtH = CDeterministicMNList();
+    std::vector<CDeterministicMNList> MnsUsedAtHIndexed(nQuorums);
+
+    for (auto i = 0; i < nQuorums; ++i) {
+        for (const auto& mn : previousQuarters.quarterHMinusC[i]) {
+            try {
+                MnsUsedAtH.AddMN(mn);
+            } catch (std::runtime_error& e) {
+            }
+            try {
+                MnsUsedAtHIndexed[i].AddMN(mn);
+            } catch (std::runtime_error& e) {
+            }
+        }
+        for (const auto& mn : previousQuarters.quarterHMinus2C[i]) {
+            try {
+                MnsUsedAtH.AddMN(mn);
+            } catch (std::runtime_error& e) {
+            }
+            try {
+                MnsUsedAtHIndexed[i].AddMN(mn);
+            } catch (std::runtime_error& e) {
+            }
+        }
+        for (const auto& mn : previousQuarters.quarterHMinus3C[i]) {
+            try {
+                MnsUsedAtH.AddMN(mn);
+            } catch (std::runtime_error& e) {
+            }
+            try {
+                MnsUsedAtHIndexed[i].AddMN(mn);
+            } catch (std::runtime_error& e) {
+            }
+        }
+    }
+
+    allMns.ForEachMNShared(true, [&MnsUsedAtH, &MnsNotUsedAtH](const CDeterministicMNCPtr& dmn) {
+        if (!MnsUsedAtH.HasMN(dmn->proTxHash)) {
+            try {
+                MnsNotUsedAtH.AddMN(dmn);
+            } catch (std::runtime_error& e) {
+            }
+        }
+    });
+
+    auto sortedMnsUsedAtHM = MnsUsedAtH.CalculateQuorum(MnsUsedAtH.GetAllMNsCount(), modifier);
+    auto sortedMnsNotUsedAtH = MnsNotUsedAtH.CalculateQuorum(MnsNotUsedAtH.GetAllMNsCount(), modifier);
+    auto sortedCombinedMnsList = std::move(sortedMnsNotUsedAtH);
+    for (auto& m : sortedMnsUsedAtHM) {
+        sortedCombinedMnsList.push_back(std::move(m));
+    }
+
+    std::stringstream ss;
+    ss << " [";
+    for (auto& m : sortedCombinedMnsList) {
+        ss << m->proTxHash.ToString().substr(0, 4) << " | ";
+    }
+    ss << "]";
+    LogPrint(BCLog::LLMQ, "BuildNewQuorumQuarterMembers h[%d] sortedCombinedMnsList:%s\n", pQuorumBaseBlockIndex->nHeight, ss.str());
+
+    std::vector<int> skipList;
+    int firstSkippedIndex = 0;
+    auto idx = 0;
+    for (auto i = 0; i < nQuorums; ++i) {
+        auto usedMNsCount = MnsUsedAtHIndexed[i].GetAllMNsCount();
+        while (quarterQuorumMembers[i].size() < quarterSize && (usedMNsCount + quarterQuorumMembers[i].size() < sortedCombinedMnsList.size())) {
+            if (!MnsUsedAtHIndexed[i].HasMN(sortedCombinedMnsList[idx]->proTxHash)) {
+                quarterQuorumMembers[i].push_back(sortedCombinedMnsList[idx]);
+            } else {
+                if (firstSkippedIndex == 0) {
+                    firstSkippedIndex = idx;
+                    skipList.push_back(idx);
+                } else {
+                    skipList.push_back(idx - firstSkippedIndex);
+                }
+            }
+            if (++idx == sortedCombinedMnsList.size()) {
+                idx = 0;
+            }
+        }
+    }
+
+    CQuorumSnapshot quorumSnapshot = {};
+
+    CLLMQComplexUtils::BuildQuorumSnapshot(llmqParams, allMns, MnsUsedAtH, sortedCombinedMnsList, quorumSnapshot, pQuorumBaseBlockIndex->nHeight, skipList, pQuorumBaseBlockIndex);
+
+    quorumSnapshotManager->StoreSnapshotForBlock(llmqParams.type, pQuorumBaseBlockIndex, quorumSnapshot);
+
+    return quarterQuorumMembers;
+}
+
+void CLLMQComplexUtils::BuildQuorumSnapshot(const Consensus::LLMQParams& llmqParams, const CDeterministicMNList& mnAtH, const CDeterministicMNList& mnUsedAtH, std::vector<CDeterministicMNCPtr>& sortedCombinedMns, CQuorumSnapshot& quorumSnapshot, int nHeight, std::vector<int>& skipList, const CBlockIndex* pQuorumBaseBlockIndex)
+{
+    quorumSnapshot.activeQuorumMembers.resize(mnAtH.GetAllMNsCount());
+    const CBlockIndex* pWorkBlockIndex = pQuorumBaseBlockIndex->GetAncestor(pQuorumBaseBlockIndex->nHeight - 8);
+    auto modifier = ::SerializeHash(std::make_pair(llmqParams.type, pWorkBlockIndex->GetBlockHash()));
+    auto sortedAllMns = mnAtH.CalculateQuorum(mnAtH.GetAllMNsCount(), modifier);
+
+    std::fill(quorumSnapshot.activeQuorumMembers.begin(),
+              quorumSnapshot.activeQuorumMembers.end(),
+              false);
+    size_t index = {};
+    for (const auto& dmn : sortedAllMns) {
+        if (mnUsedAtH.HasMN(dmn->proTxHash)) {
+            quorumSnapshot.activeQuorumMembers[index] = true;
+        }
+        index++;
+    }
+
+    if (skipList.empty()) {
+        quorumSnapshot.mnSkipListMode = SnapshotSkipMode::MODE_NO_SKIPPING;
+        quorumSnapshot.mnSkipList.clear();
+    } else {
+        quorumSnapshot.mnSkipListMode = SnapshotSkipMode::MODE_SKIPPING_ENTRIES;
+        quorumSnapshot.mnSkipList = std::move(skipList);
+    }
+}
+
+std::vector<std::vector<CDeterministicMNCPtr>> CLLMQComplexUtils::GetQuorumQuarterMembersBySnapshot(const Consensus::LLMQParams& llmqParams, const CBlockIndex* pQuorumBaseBlockIndex, const llmq::CQuorumSnapshot& snapshot, int nHeight)
+{
+    std::vector<CDeterministicMNCPtr> sortedCombinedMns;
+    {
+        const CBlockIndex* pWorkBlockIndex = pQuorumBaseBlockIndex->GetAncestor(pQuorumBaseBlockIndex->nHeight - 8);
+        const auto modifier = ::SerializeHash(std::make_pair(llmqParams.type, pWorkBlockIndex->GetBlockHash()));
+        const auto [MnsUsedAtH, MnsNotUsedAtH] = CLLMQComplexUtils::GetMNUsageBySnapshot(llmqParams.type, pQuorumBaseBlockIndex, snapshot, nHeight);
+        // the list begins with all the unused MNs
+        auto sortedMnsNotUsedAtH = MnsNotUsedAtH.CalculateQuorum(MnsNotUsedAtH.GetAllMNsCount(), modifier);
+        sortedCombinedMns = std::move(sortedMnsNotUsedAtH);
+        // Now add the already used MNs to the end of the list
+        auto sortedMnsUsedAtH = MnsUsedAtH.CalculateQuorum(MnsUsedAtH.GetAllMNsCount(), modifier);
+        std::move(sortedMnsUsedAtH.begin(), sortedMnsUsedAtH.end(), std::back_inserter(sortedCombinedMns));
+    }
+
+    if (sortedCombinedMns.empty()) return {};
+
+    auto numQuorums = size_t(llmqParams.signingActiveQuorumCount);
+    auto quorumSize = size_t(llmqParams.size);
+    auto quarterSize = quorumSize / 4;
+
+    std::vector<std::vector<CDeterministicMNCPtr>> quarterQuorumMembers(numQuorums);
+
+    switch (snapshot.mnSkipListMode) {
+        case SnapshotSkipMode::MODE_NO_SKIPPING:
+        {
+            auto itm = sortedCombinedMns.begin();
+            for (auto i = 0; i < llmqParams.signingActiveQuorumCount; ++i) {
+                while (quarterQuorumMembers[i].size() < quarterSize) {
+                    quarterQuorumMembers[i].push_back(*itm);
+                    itm++;
+                    if (itm == sortedCombinedMns.end()) {
+                        itm = sortedCombinedMns.begin();
+                    }
+                }
+            }
+            return quarterQuorumMembers;
+        }
+        case SnapshotSkipMode::MODE_SKIPPING_ENTRIES: // List holds entries to be skipped
+        {
+            size_t first_entry_index{0};
+            std::vector<int> processesdSkipList;
+            for (const auto& s : snapshot.mnSkipList) {
+                if (first_entry_index == 0) {
+                    first_entry_index = s;
+                    processesdSkipList.push_back(s);
+                } else {
+                    processesdSkipList.push_back(first_entry_index + s);
+                }
+            }
+
+            auto idx = 0;
+            auto itsk = processesdSkipList.begin();
+            for (auto i = 0; i < llmqParams.signingActiveQuorumCount; ++i) {
+                while (quarterQuorumMembers[i].size() < quarterSize) {
+                    if (itsk != processesdSkipList.end() && idx == *itsk) {
+                        itsk++;
+                    } else {
+                        quarterQuorumMembers[i].push_back(sortedCombinedMns[idx]);
+                    }
+                    idx++;
+                    if (idx == sortedCombinedMns.size()) {
+                        idx = 0;
+                    }
+                }
+            }
+            return quarterQuorumMembers;
+        }
+        case SnapshotSkipMode::MODE_NO_SKIPPING_ENTRIES: // List holds entries to be kept
+        case SnapshotSkipMode::MODE_ALL_SKIPPED: // Every node was skipped. Returning empty quarterQuorumMembers
+        default:
+            return {};
+    }
+}
+
+std::pair<CDeterministicMNList, CDeterministicMNList> CLLMQComplexUtils::GetMNUsageBySnapshot(Consensus::LLMQType llmqType, const CBlockIndex* pQuorumBaseBlockIndex, const llmq::CQuorumSnapshot& snapshot, int nHeight)
+{
+    CDeterministicMNList usedMNs;
+    CDeterministicMNList nonUsedMNs;
+    LOCK(deterministicMNManager->cs);
+
+    const CBlockIndex* pWorkBlockIndex = pQuorumBaseBlockIndex->GetAncestor(pQuorumBaseBlockIndex->nHeight - 8);
+    auto modifier = ::SerializeHash(std::make_pair(llmqType, pWorkBlockIndex->GetBlockHash()));
+
+    auto Mns = deterministicMNManager->GetListForBlock(pWorkBlockIndex);
+    auto sortedAllMns = Mns.CalculateQuorum(Mns.GetAllMNsCount(), modifier);
+
+    size_t i{0};
+    for (const auto& dmn : sortedAllMns) {
+        if (snapshot.activeQuorumMembers[i]) {
+            try {
+                usedMNs.AddMN(dmn);
+            } catch (std::runtime_error& e) {
+            }
+        } else {
+            try {
+                nonUsedMNs.AddMN(dmn);
+            } catch (std::runtime_error& e) {
+            }
+        }
+        i++;
+    }
+
+    return std::make_pair(usedMNs, nonUsedMNs);
+}
+
+Consensus::LLMQType CLLMQComplexUtils::GetInstantSendLLMQType(const CBlockIndex* pindex)
+{
+    if (CLLMQUtils::IsDIP0024Active(pindex) && !quorumManager->ScanQuorums(Params().GetConsensus().llmqTypeDIP0024InstantSend, pindex, 1).empty()) {
+        return Params().GetConsensus().llmqTypeDIP0024InstantSend;
+    }
+    return Params().GetConsensus().llmqTypeInstantSend;
+}
+
+std::set<uint256> CLLMQComplexUtils::GetQuorumConnections(const Consensus::LLMQParams& llmqParams, const CBlockIndex* pQuorumBaseBlockIndex, const uint256& forMember, bool onlyOutbound)
+{
+    if (CLLMQUtils::IsAllMembersConnectedEnabled(llmqParams.type)) {
+        auto mns = GetAllQuorumMembers(llmqParams.type, pQuorumBaseBlockIndex);
+        std::set<uint256> result;
+
+        for (const auto& dmn : mns) {
+            if (dmn->proTxHash == forMember) {
+                continue;
+            }
+            // Determine which of the two MNs (forMember vs dmn) should initiate the outbound connection and which
+            // one should wait for the inbound connection. We do this in a deterministic way, so that even when we
+            // end up with both connecting to each other, we know which one to disconnect
+            uint256 deterministicOutbound = CLLMQUtils::DeterministicOutboundConnection(forMember, dmn->proTxHash);
+            if (!onlyOutbound || deterministicOutbound == dmn->proTxHash) {
+                result.emplace(dmn->proTxHash);
+            }
+        }
+        return result;
+    } else {
+        return GetQuorumRelayMembers(llmqParams, pQuorumBaseBlockIndex, forMember, onlyOutbound);
+    }
+}
+
+std::set<uint256> CLLMQComplexUtils::GetQuorumRelayMembers(const Consensus::LLMQParams& llmqParams, const CBlockIndex* pQuorumBaseBlockIndex, const uint256& forMember, bool onlyOutbound)
+{
+    auto mns = CLLMQComplexUtils::GetAllQuorumMembers(llmqParams.type, pQuorumBaseBlockIndex);
+    std::set<uint256> result;
+
+    auto calcOutbound = [&](size_t i, const uint256& proTxHash) {
+        // Relay to nodes at indexes (i+2^k)%n, where
+        //   k: 0..max(1, floor(log2(n-1))-1)
+        //   n: size of the quorum/ring
+        std::set<uint256> r;
+        int gap = 1;
+        int gap_max = (int)mns.size() - 1;
+        int k = 0;
+        while ((gap_max >>= 1) || k <= 1) {
+            size_t idx = (i + gap) % mns.size();
+            const auto& otherDmn = mns[idx];
+            if (otherDmn->proTxHash == proTxHash) {
+                continue;
+            }
+            r.emplace(otherDmn->proTxHash);
+            gap <<= 1;
+            k++;
+        }
+        return r;
+    };
+
+    for (size_t i = 0; i < mns.size(); i++) {
+        const auto& dmn = mns[i];
+        if (dmn->proTxHash == forMember) {
+            auto r = calcOutbound(i, dmn->proTxHash);
+            result.insert(r.begin(), r.end());
+        } else if (!onlyOutbound) {
+            auto r = calcOutbound(i, dmn->proTxHash);
+            if (r.count(forMember)) {
+                result.emplace(dmn->proTxHash);
+            }
+        }
+    }
+
+    return result;
+}
+
+bool CLLMQComplexUtils::EnsureQuorumConnections(const Consensus::LLMQParams& llmqParams, const CBlockIndex* pQuorumBaseBlockIndex, CConnman& connman, const uint256& myProTxHash)
+{
+    auto members = GetAllQuorumMembers(llmqParams.type, pQuorumBaseBlockIndex);
+    bool isMember = std::find_if(members.begin(), members.end(), [&](const auto& dmn) { return dmn->proTxHash == myProTxHash; }) != members.end();
+
+    if (!isMember && !CLLMQUtils::IsWatchQuorumsEnabled()) {
+        return false;
+    }
+
+    std::set<uint256> connections;
+    std::set<uint256> relayMembers;
+    if (isMember) {
+        connections = CLLMQComplexUtils::GetQuorumConnections(llmqParams, pQuorumBaseBlockIndex, myProTxHash, true);
+        relayMembers = CLLMQComplexUtils::GetQuorumRelayMembers(llmqParams, pQuorumBaseBlockIndex, myProTxHash, true);
+    } else {
+        auto cindexes = CalcDeterministicWatchConnections(llmqParams.type, pQuorumBaseBlockIndex, members.size(), 1);
+        for (auto idx : cindexes) {
+            connections.emplace(members[idx]->proTxHash);
+        }
+        relayMembers = connections;
+    }
+    if (!connections.empty()) {
+        if (!connman.HasMasternodeQuorumNodes(llmqParams.type, pQuorumBaseBlockIndex->GetBlockHash()) && LogAcceptCategory(BCLog::LLMQ)) {
+            auto mnList = deterministicMNManager->GetListAtChainTip();
+            std::string debugMsg = strprintf("CLLMQComplexUtils::%s -- adding masternodes quorum connections for quorum %s:\n", __func__, pQuorumBaseBlockIndex->GetBlockHash().ToString());
+            for (auto& c : connections) {
+                auto dmn = mnList.GetValidMN(c);
+                if (!dmn) {
+                    debugMsg += strprintf("  %s (not in valid MN set anymore)\n", c.ToString());
+                } else {
+                    debugMsg += strprintf("  %s (%s)\n", c.ToString(), dmn->pdmnState->addr.ToString(false));
+                }
+            }
+            LogPrint(BCLog::NET_NETCONN, debugMsg.c_str()); /* Continued */
+        }
+        connman.SetMasternodeQuorumNodes(llmqParams.type, pQuorumBaseBlockIndex->GetBlockHash(), connections);
+    }
+    if (!relayMembers.empty()) {
+        connman.SetMasternodeQuorumRelayMembers(llmqParams.type, pQuorumBaseBlockIndex->GetBlockHash(), relayMembers);
+    }
+    return true;
+}
+
+void CLLMQComplexUtils::AddQuorumProbeConnections(const Consensus::LLMQParams& llmqParams, const CBlockIndex *pQuorumBaseBlockIndex, CConnman& connman, const uint256 &myProTxHash)
+{
+    if (!CLLMQUtils::IsQuorumPoseEnabled(llmqParams.type)) {
+        return;
+    }
+
+    auto members = GetAllQuorumMembers(llmqParams.type, pQuorumBaseBlockIndex);
+    auto curTime = GetAdjustedTime();
+
+    std::set<uint256> probeConnections;
+    for (const auto& dmn : members) {
+        if (dmn->proTxHash == myProTxHash) {
+            continue;
+        }
+        auto lastOutbound = mmetaman.GetMetaInfo(dmn->proTxHash)->GetLastOutboundSuccess();
+        // re-probe after 50 minutes so that the "good connection" check in the DKG doesn't fail just because we're on
+        // the brink of timeout
+        if (curTime - lastOutbound > 50 * 60) {
+            probeConnections.emplace(dmn->proTxHash);
+        }
+    }
+
+    if (!probeConnections.empty()) {
+        if (LogAcceptCategory(BCLog::LLMQ)) {
+            auto mnList = deterministicMNManager->GetListAtChainTip();
+            std::string debugMsg = strprintf("CLLMQComplexUtils::%s -- adding masternodes probes for quorum %s:\n", __func__, pQuorumBaseBlockIndex->GetBlockHash().ToString());
+            for (auto& c : probeConnections) {
+                auto dmn = mnList.GetValidMN(c);
+                if (!dmn) {
+                    debugMsg += strprintf("  %s (not in valid MN set anymore)\n", c.ToString());
+                } else {
+                    debugMsg += strprintf("  %s (%s)\n", c.ToString(), dmn->pdmnState->addr.ToString(false));
+                }
+            }
+            LogPrint(BCLog::NET_NETCONN, debugMsg.c_str()); /* Continued */
+        }
+        connman.AddPendingProbeConnections(probeConnections);
+    }
+}
+
+bool CLLMQComplexUtils::IsQuorumActive(Consensus::LLMQType llmqType, const uint256& quorumHash)
+{
+    // sig shares and recovered sigs are only accepted from recent/active quorums
+    // we allow one more active quorum as specified in consensus, as otherwise there is a small window where things could
+    // fail while we are on the brink of a new quorum
+    auto quorums = quorumManager->ScanQuorums(llmqType, GetLLMQParams(llmqType).signingActiveQuorumCount + 1);
+    return ranges::any_of(quorums, [&quorumHash](const auto& q){ return q->qc->quorumHash == quorumHash; });
+}
+
+bool CLLMQComplexUtils::IsQuorumTypeEnabled(Consensus::LLMQType llmqType, const CBlockIndex* pindex)
+{
+    return IsQuorumTypeEnabledInternal(llmqType, pindex, std::nullopt, std::nullopt);
+}
+
+bool CLLMQComplexUtils::IsQuorumTypeEnabledInternal(Consensus::LLMQType llmqType, const CBlockIndex* pindex, std::optional<bool> optDIP0024IsActive, std::optional<bool> optHaveDIP0024Quorums)
+{
+    const Consensus::Params& consensusParams = Params().GetConsensus();
+
+    switch (llmqType)
+    {
+        case Consensus::LLMQType::LLMQ_TEST_INSTANTSEND:
+        case Consensus::LLMQType::LLMQ_50_60: {
+            bool fDIP0024IsActive = optDIP0024IsActive.has_value() ? *optDIP0024IsActive : CLLMQUtils::IsDIP0024Active(pindex);
+            if (fDIP0024IsActive) {
+                bool fHaveDIP0024Quorums = optHaveDIP0024Quorums.has_value() ? *optHaveDIP0024Quorums
+                                                                             : !quorumManager->ScanQuorums(
+                                consensusParams.llmqTypeDIP0024InstantSend, pindex, 1).empty();
+                if (fHaveDIP0024Quorums) {
+                    return false;
+                }
+            }
+            break;
+        }
+        case Consensus::LLMQType::LLMQ_TEST:
+        case Consensus::LLMQType::LLMQ_400_60:
+        case Consensus::LLMQType::LLMQ_400_85:
+            break;
+        case Consensus::LLMQType::LLMQ_100_67:
+        case Consensus::LLMQType::LLMQ_TEST_V17:
+            if (LOCK(cs_llmq_vbc); VersionBitsState(pindex, consensusParams, Consensus::DEPLOYMENT_DIP0020, llmq_versionbitscache) != ThresholdState::ACTIVE) {
+                return false;
+            }
+            break;
+        case Consensus::LLMQType::LLMQ_60_75:
+        case Consensus::LLMQType::LLMQ_TEST_DIP0024: {
+            bool fDIP0024IsActive = optDIP0024IsActive.has_value() ? *optDIP0024IsActive : CLLMQUtils::IsDIP0024Active(pindex);
+            if (!fDIP0024IsActive) {
+                return false;
+            }
+            break;
+        }
+        case Consensus::LLMQType::LLMQ_DEVNET:
+            break;
+        default:
+            throw std::runtime_error(strprintf("%s: Unknown LLMQ type %d", __func__, static_cast<uint8_t>(llmqType)));
+    }
+
+    return true;
+}
+
+std::vector<Consensus::LLMQType> CLLMQComplexUtils::GetEnabledQuorumTypes(const CBlockIndex* pindex)
+{
+    std::vector<Consensus::LLMQType> ret;
+    ret.reserve(Params().GetConsensus().llmqs.size());
+    for (const auto& params : Params().GetConsensus().llmqs) {
+        if (IsQuorumTypeEnabled(params.type, pindex)) {
+            ret.push_back(params.type);
+        }
+    }
+    return ret;
+}
+
+std::vector<std::reference_wrapper<const Consensus::LLMQParams>> CLLMQComplexUtils::GetEnabledQuorumParams(const CBlockIndex* pindex)
+{
+    std::vector<std::reference_wrapper<const Consensus::LLMQParams>> ret;
+    ret.reserve(Params().GetConsensus().llmqs.size());
+
+    std::copy_if(Params().GetConsensus().llmqs.begin(), Params().GetConsensus().llmqs.end(), std::back_inserter(ret),
+                 [&pindex](const auto& params){return IsQuorumTypeEnabled(params.type, pindex);});
+
+    return ret;
+}
+
+std::vector<CDeterministicMNCPtr> CLLMQComplexUtils::GetAllQuorumMembers(Consensus::LLMQType llmqType, const CBlockIndex* pQuorumBaseBlockIndex)
+{
+    static CCriticalSection cs_members;
+    static std::map<Consensus::LLMQType, unordered_lru_cache<uint256, std::vector<CDeterministicMNCPtr>, StaticSaltedHasher>> mapQuorumMembers GUARDED_BY(cs_members);
+    static CCriticalSection cs_indexed_members;
+    static std::map<Consensus::LLMQType, unordered_lru_cache<std::pair<uint256, int>, std::vector<CDeterministicMNCPtr>, StaticSaltedHasher>> mapIndexedQuorumMembers GUARDED_BY(cs_indexed_members);
+    if (!IsQuorumTypeEnabled(llmqType, pQuorumBaseBlockIndex->pprev)) {
+        return {};
+    }
+    std::vector<CDeterministicMNCPtr> quorumMembers;
+    {
+        LOCK(cs_members);
+        if (mapQuorumMembers.empty()) {
+            InitQuorumsCache(mapQuorumMembers);
+        }
+        if (mapQuorumMembers[llmqType].get(pQuorumBaseBlockIndex->GetBlockHash(), quorumMembers)) {
+            return quorumMembers;
+        }
+    }
+
+    if (CLLMQUtils::IsQuorumRotationEnabled(llmqType, pQuorumBaseBlockIndex)) {
+        if (LOCK(cs_indexed_members); mapIndexedQuorumMembers.empty()) {
+            InitQuorumsCache(mapIndexedQuorumMembers);
+        }
+        /*
+         * Quorums created with rotation are now created in a different way. All signingActiveQuorumCount are created during the period of dkgInterval.
+         * But they are not created exactly in the same block, they are spreaded overtime: one quorum in each block until all signingActiveQuorumCount are created.
+         * The new concept of quorumIndex is introduced in order to identify them.
+         * In every dkgInterval blocks (also called CycleQuorumBaseBlock), the spreaded quorum creation starts like this:
+         * For quorumIndex = 0 : signingActiveQuorumCount
+         * Quorum Q with quorumIndex is created at height CycleQuorumBaseBlock + quorumIndex
+         */
+
+        const Consensus::LLMQParams& llmqParams = GetLLMQParams(llmqType);
+        int quorumIndex = pQuorumBaseBlockIndex->nHeight % llmqParams.dkgInterval;
+        if (quorumIndex >= llmqParams.signingActiveQuorumCount) {
+            return {};
+        }
+        int cycleQuorumBaseHeight = pQuorumBaseBlockIndex->nHeight - quorumIndex;
+        const CBlockIndex* pCycleQuorumBaseBlockIndex = pQuorumBaseBlockIndex->GetAncestor(cycleQuorumBaseHeight);
+
+        /*
+         * Since mapQuorumMembers stores Quorum members per block hash, and we don't know yet the block hashes of blocks for all quorumIndexes (since these blocks are not created yet)
+         * We store them in a second cache mapIndexedQuorumMembers which stores them by {CycleQuorumBaseBlockHash, quorumIndex}
+         */
+        if (LOCK(cs_indexed_members); mapIndexedQuorumMembers[llmqType].get(std::pair(pCycleQuorumBaseBlockIndex->GetBlockHash(), quorumIndex), quorumMembers)) {
+            LOCK(cs_members);
+            mapQuorumMembers[llmqType].insert(pQuorumBaseBlockIndex->GetBlockHash(), quorumMembers);
+            return quorumMembers;
+        }
+
+        auto q = ComputeQuorumMembersByQuarterRotation(llmqType, pCycleQuorumBaseBlockIndex);
+        LOCK(cs_indexed_members);
+        for (int i = 0; i < static_cast<int>(q.size()); ++i) {
+            mapIndexedQuorumMembers[llmqType].insert(std::make_pair(pCycleQuorumBaseBlockIndex->GetBlockHash(), i), q[i]);
+        }
+
+        quorumMembers = q[quorumIndex];
+    } else {
+        quorumMembers = ComputeQuorumMembers(llmqType, pQuorumBaseBlockIndex);
+    }
+
+    LOCK(cs_members);
+    mapQuorumMembers[llmqType].insert(pQuorumBaseBlockIndex->GetBlockHash(), quorumMembers);
+    return quorumMembers;
+}
+
+void CLLMQComplexUtils::PreComputeQuorumMembers(const CBlockIndex* pQuorumBaseBlockIndex)
+{
+    for (const Consensus::LLMQParams& params : GetEnabledQuorumParams(pQuorumBaseBlockIndex->pprev)) {
+        if (llmq::CLLMQUtils::IsQuorumRotationEnabled(params.type, pQuorumBaseBlockIndex) && (pQuorumBaseBlockIndex->nHeight % params.dkgInterval == 0)) {
+            GetAllQuorumMembers(params.type, pQuorumBaseBlockIndex);
+        }
+    }
+}
+
+template <typename CacheType>
+void CLLMQComplexUtils::InitQuorumsCache(CacheType& cache)
+{
+    for (auto& llmq : Params().GetConsensus().llmqs) {
+        cache.emplace(std::piecewise_construct, std::forward_as_tuple(llmq.type),
+                      std::forward_as_tuple(llmq.signingActiveQuorumCount + 1));
+    }
+}
+
+template void CLLMQComplexUtils::InitQuorumsCache<std::map<Consensus::LLMQType, unordered_lru_cache<uint256, bool, StaticSaltedHasher>>>(std::map<Consensus::LLMQType, unordered_lru_cache<uint256, bool, StaticSaltedHasher>>& cache);
+template void CLLMQComplexUtils::InitQuorumsCache<std::map<Consensus::LLMQType, unordered_lru_cache<uint256, std::vector<CQuorumCPtr>, StaticSaltedHasher>>>(std::map<Consensus::LLMQType, unordered_lru_cache<uint256, std::vector<CQuorumCPtr>, StaticSaltedHasher>>& cache);
+template void CLLMQComplexUtils::InitQuorumsCache<std::map<Consensus::LLMQType, unordered_lru_cache<uint256, std::shared_ptr<llmq::CQuorum>, StaticSaltedHasher, 0ul, 0ul>, std::less<Consensus::LLMQType>, std::allocator<std::pair<Consensus::LLMQType const, unordered_lru_cache<uint256, std::shared_ptr<llmq::CQuorum>, StaticSaltedHasher, 0ul, 0ul>>>>>(std::map<Consensus::LLMQType, unordered_lru_cache<uint256, std::shared_ptr<llmq::CQuorum>, StaticSaltedHasher, 0ul, 0ul>, std::less<Consensus::LLMQType>, std::allocator<std::pair<Consensus::LLMQType const, unordered_lru_cache<uint256, std::shared_ptr<llmq::CQuorum>, StaticSaltedHasher, 0ul, 0ul>>>>&);
+template void CLLMQComplexUtils::InitQuorumsCache<std::map<Consensus::LLMQType, unordered_lru_cache<uint256, int, StaticSaltedHasher>>>(std::map<Consensus::LLMQType, unordered_lru_cache<uint256, int, StaticSaltedHasher>>& cache);
+
+
+std::set<size_t> CLLMQComplexUtils::CalcDeterministicWatchConnections(Consensus::LLMQType llmqType, const CBlockIndex* pQuorumBaseBlockIndex, size_t memberCount, size_t connectionCount)
+{
+    static uint256 qwatchConnectionSeed;
+    static std::atomic<bool> qwatchConnectionSeedGenerated{false};
+    static CCriticalSection qwatchConnectionSeedCs;
+    if (!qwatchConnectionSeedGenerated) {
+        LOCK(qwatchConnectionSeedCs);
+        qwatchConnectionSeed = GetRandHash();
+        qwatchConnectionSeedGenerated = true;
+    }
+
+    std::set<size_t> result;
+    uint256 rnd = qwatchConnectionSeed;
+    for (size_t i = 0; i < connectionCount; i++) {
+        rnd = ::SerializeHash(std::make_pair(rnd, std::make_pair(llmqType, pQuorumBaseBlockIndex->GetBlockHash())));
+        result.emplace(rnd.GetUint64(0) % memberCount);
+    }
+    return result;
+}
+
+
+} // namespace llmq
diff --git a/src/llmq/complex_utils.h b/src/llmq/complex_utils.h
new file mode 100644
index 000000000000..3f1de48c637a
--- /dev/null
+++ b/src/llmq/complex_utils.h
@@ -0,0 +1,83 @@
+// Copyright (c) 2018-2021 The Dash Core developers
+// Distributed under the MIT software license, see the accompanying
+// file COPYING or http://www.opensource.org/licenses/mit-license.php.
+
+#ifndef BITCOIN_LLMQ_COMPLEX_UTILS_H
+#define BITCOIN_LLMQ_COMPLEX_UTILS_H
+
+#include <consensus/params.h>
+
+#include <random.h>
+#include <versionbits.h>
+
+#include <vector>
+#include <memory>
+#include <set>
+#include <optional>
+
+class CConnman;
+class CBlockIndex;
+class CDeterministicMN;
+class CDeterministicMNList;
+using CDeterministicMNCPtr = std::shared_ptr<const CDeterministicMN>;
+class CBLSPublicKey;
+
+namespace llmq
+{
+
+class CQuorumSnapshot;
+
+//QuorumMembers per quorumIndex at heights H-Cycle, H-2Cycles, H-3Cycles
+struct PreviousQuorumQuarters {
+    std::vector<std::vector<CDeterministicMNCPtr>> quarterHMinusC;
+    std::vector<std::vector<CDeterministicMNCPtr>> quarterHMinus2C;
+    std::vector<std::vector<CDeterministicMNCPtr>> quarterHMinus3C;
+    explicit PreviousQuorumQuarters(size_t s) :
+            quarterHMinusC(s), quarterHMinus2C(s), quarterHMinus3C(s) {}
+};
+
+class CLLMQComplexUtils
+{
+public:
+    // includes members which failed DKG
+    static std::vector<CDeterministicMNCPtr> GetAllQuorumMembers(Consensus::LLMQType llmqType, const CBlockIndex* pQuorumBaseBlockIndex);
+
+    static void PreComputeQuorumMembers(const CBlockIndex* pQuorumBaseBlockIndex);
+
+    static std::vector<CDeterministicMNCPtr> ComputeQuorumMembers(Consensus::LLMQType llmqType, const CBlockIndex* pQuorumBaseBlockIndex);
+    static std::vector<std::vector<CDeterministicMNCPtr>> ComputeQuorumMembersByQuarterRotation(Consensus::LLMQType llmqType, const CBlockIndex* pCycleQuorumBaseBlockIndex);
+
+    static std::vector<std::vector<CDeterministicMNCPtr>> BuildNewQuorumQuarterMembers(const Consensus::LLMQParams& llmqParams, const CBlockIndex* pQuorumBaseBlockIndex, const PreviousQuorumQuarters& quarters);
+
+    static PreviousQuorumQuarters GetPreviousQuorumQuarterMembers(const Consensus::LLMQParams& llmqParams, const CBlockIndex* pBlockHMinusCIndex, const CBlockIndex* pBlockHMinus2CIndex, const CBlockIndex* pBlockHMinus3CIndex, int nHeight);
+    static std::vector<std::vector<CDeterministicMNCPtr>> GetQuorumQuarterMembersBySnapshot(const Consensus::LLMQParams& llmqParams, const CBlockIndex* pQuorumBaseBlockIndex, const llmq::CQuorumSnapshot& snapshot, int nHeights);
+    static std::pair<CDeterministicMNList, CDeterministicMNList> GetMNUsageBySnapshot(Consensus::LLMQType llmqType, const CBlockIndex* pQuorumBaseBlockIndex, const llmq::CQuorumSnapshot& snapshot, int nHeight);
+
+    static void BuildQuorumSnapshot(const Consensus::LLMQParams& llmqParams, const CDeterministicMNList& mnAtH, const CDeterministicMNList& mnUsedAtH, std::vector<CDeterministicMNCPtr>& sortedCombinedMns, CQuorumSnapshot& quorumSnapshot, int nHeight, std::vector<int>& skipList, const CBlockIndex* pQuorumBaseBlockIndex);
+
+    static std::set<uint256> GetQuorumConnections(const Consensus::LLMQParams& llmqParams, const CBlockIndex* pQuorumBaseBlockIndex, const uint256& forMember, bool onlyOutbound);
+    static std::set<uint256> GetQuorumRelayMembers(const Consensus::LLMQParams& llmqParams, const CBlockIndex* pQuorumBaseBlockIndex, const uint256& forMember, bool onlyOutbound);
+
+    static bool EnsureQuorumConnections(const Consensus::LLMQParams& llmqParams, const CBlockIndex* pQuorumBaseBlockIndex, CConnman& connman, const uint256& myProTxHash);
+    static void AddQuorumProbeConnections(const Consensus::LLMQParams& llmqParams, const CBlockIndex* pQuorumBaseBlockIndex, CConnman& connman, const uint256& myProTxHash);
+
+    static bool IsQuorumActive(Consensus::LLMQType llmqType, const uint256& quorumHash);
+    static bool IsQuorumTypeEnabled(Consensus::LLMQType llmqType, const CBlockIndex* pindex);
+    static bool IsQuorumTypeEnabledInternal(Consensus::LLMQType llmqType, const CBlockIndex* pindex, std::optional<bool> optDIP0024IsActive, std::optional<bool> optHaveDIP0024Quorums);
+
+    static Consensus::LLMQType GetInstantSendLLMQType(const CBlockIndex* pindex);
+
+    static std::vector<Consensus::LLMQType> GetEnabledQuorumTypes(const CBlockIndex* pindex);
+    static std::vector<std::reference_wrapper<const Consensus::LLMQParams>> GetEnabledQuorumParams(const CBlockIndex* pindex);
+
+    template <typename CacheType>
+    static void InitQuorumsCache(CacheType& cache);
+
+
+    static std::set<size_t> CalcDeterministicWatchConnections(Consensus::LLMQType llmqType, const CBlockIndex* pQuorumBaseBlockIndex, size_t memberCount, size_t connectionCount);
+
+};
+
+} // namespace llmq
+
+#endif // BITCOIN_LLMQ_COMPLEX_UTILS_H
diff --git a/src/llmq/debug.cpp b/src/llmq/debug.cpp
index ee93d879cbb9..a6d167e62de9 100644
--- a/src/llmq/debug.cpp
+++ b/src/llmq/debug.cpp
@@ -10,6 +10,7 @@
 
 #include <evo/deterministicmns.h>
 #include <llmq/utils.h>
+#include <llmq/complex_utils.h>
 #include <util/irange.h>
 
 namespace llmq
@@ -28,7 +29,7 @@ UniValue CDKGDebugSessionStatus::ToJson(int quorumIndex, int detailLevel) const
     if (detailLevel == 2) {
         const CBlockIndex* pindex = WITH_LOCK(cs_main, return LookupBlockIndex(quorumHash));
         if (pindex != nullptr) {
-            dmnMembers = CLLMQUtils::GetAllQuorumMembers(llmqType, pindex);
+            dmnMembers = CLLMQComplexUtils::GetAllQuorumMembers(llmqType, pindex);
         }
     }
 
diff --git a/src/llmq/dkgsession.cpp b/src/llmq/dkgsession.cpp
index 9d5d8a1954fc..3f02d2d6d45c 100644
--- a/src/llmq/dkgsession.cpp
+++ b/src/llmq/dkgsession.cpp
@@ -7,6 +7,8 @@
 #include <llmq/commitment.h>
 #include <llmq/debug.h>
 #include <llmq/dkgsessionmgr.h>
+#include <llmq/utils.h>
+#include <llmq/complex_utils.h>
 
 #include <evo/deterministicmns.h>
 #include <evo/specialtx.h>
@@ -117,7 +119,7 @@ bool CDKGSession::Init(const CBlockIndex* _pQuorumBaseBlockIndex, const std::vec
 
     if (!myProTxHash.IsNull()) {
         quorumDKGDebugManager->InitLocalSessionStatus(params, quorumIndex, m_quorum_base_block_index->GetBlockHash(), m_quorum_base_block_index->nHeight);
-        relayMembers = CLLMQUtils::GetQuorumRelayMembers(params, m_quorum_base_block_index, myProTxHash, true);
+        relayMembers = CLLMQComplexUtils::GetQuorumRelayMembers(params, m_quorum_base_block_index, myProTxHash, true);
         std::stringstream ss;
         for (const auto& r : relayMembers) {
             ss << r.ToString().substr(0, 4) << " | ";
@@ -1340,4 +1342,10 @@ void CDKGSession::RelayInvToParticipants(const CInv& inv) const
     logger.Flush();
 }
 
+uint256 CDKGPrematureCommitment::GetSignHash() const
+{
+    return CLLMQUtils::BuildCommitmentHash(llmqType, quorumHash, validMembers, quorumPublicKey, quorumVvecHash);
+}
+
+
 } // namespace llmq
diff --git a/src/llmq/dkgsession.h b/src/llmq/dkgsession.h
index 67286140f286..bcd1b7033579 100644
--- a/src/llmq/dkgsession.h
+++ b/src/llmq/dkgsession.h
@@ -11,7 +11,9 @@
 #include <bls/bls_worker.h>
 
 #include <llmq/commitment.h>
-#include <llmq/utils.h>
+#include <chain.h>
+#include <serialize.h>
+#include <sync.h>
 
 #include <optional>
 
@@ -19,6 +21,9 @@ class UniValue;
 class CInv;
 class CConnman;
 
+class CDeterministicMN;
+using CDeterministicMNCPtr = std::shared_ptr<const CDeterministicMN>;
+
 namespace llmq
 {
 
@@ -181,10 +186,7 @@ class CDKGPrematureCommitment
                 );
     }
 
-    [[nodiscard]] uint256 GetSignHash() const
-    {
-        return CLLMQUtils::BuildCommitmentHash(llmqType, quorumHash, validMembers, quorumPublicKey, quorumVvecHash);
-    }
+    [[nodiscard]] uint256 GetSignHash() const;
 };
 
 class CDKGMember
diff --git a/src/llmq/dkgsessionhandler.cpp b/src/llmq/dkgsessionhandler.cpp
index 00afb995c164..fed4968c4bac 100644
--- a/src/llmq/dkgsessionhandler.cpp
+++ b/src/llmq/dkgsessionhandler.cpp
@@ -9,6 +9,7 @@
 #include <llmq/blockprocessor.h>
 #include <llmq/debug.h>
 #include <llmq/utils.h>
+#include <llmq/complex_utils.h>
 
 #include <evo/deterministicmns.h>
 
@@ -147,7 +148,7 @@ bool CDKGSessionHandler::InitNewQuorum(const CBlockIndex* pQuorumBaseBlockIndex)
         return false;
     }
 
-    auto mns = CLLMQUtils::GetAllQuorumMembers(params.type, pQuorumBaseBlockIndex);
+    auto mns = CLLMQComplexUtils::GetAllQuorumMembers(params.type, pQuorumBaseBlockIndex);
     if (!curSession->Init(pQuorumBaseBlockIndex, mns, WITH_LOCK(activeMasternodeInfoCs, return activeMasternodeInfo.proTxHash), quorumIndex)) {
         LogPrintf("CDKGSessionManager::%s -- height[%d] quorum initialization failed for %s mns[%d]\n", __func__, pQuorumBaseBlockIndex->nHeight, curSession->params.name, mns.size());
         return false;
@@ -491,9 +492,9 @@ void CDKGSessionHandler::HandleDKGRound()
         return changed;
     });
 
-    CLLMQUtils::EnsureQuorumConnections(params, pQuorumBaseBlockIndex, connman, curSession->myProTxHash);
+    CLLMQComplexUtils::EnsureQuorumConnections(params, pQuorumBaseBlockIndex, connman, curSession->myProTxHash);
     if (curSession->AreWeMember()) {
-        CLLMQUtils::AddQuorumProbeConnections(params, pQuorumBaseBlockIndex, connman, curSession->myProTxHash);
+        CLLMQComplexUtils::AddQuorumProbeConnections(params, pQuorumBaseBlockIndex, connman, curSession->myProTxHash);
     }
 
     WaitForNextPhase(QuorumPhase::Initialized, QuorumPhase::Contribute, curQuorumHash);
diff --git a/src/llmq/dkgsessionmgr.cpp b/src/llmq/dkgsessionmgr.cpp
index 694c56670f42..12024d1a38f1 100644
--- a/src/llmq/dkgsessionmgr.cpp
+++ b/src/llmq/dkgsessionmgr.cpp
@@ -4,10 +4,12 @@
 
 #include <llmq/debug.h>
 #include <llmq/dkgsessionmgr.h>
-#include <llmq/quorums.h>
 #include <llmq/utils.h>
+#include <llmq/complex_utils.h>
 
 #include <evo/deterministicmns.h>
+#include <unordered_lru_cache.h>
+#include <dbwrapper.h>
 
 #include <chainparams.h>
 #include <net_processing.h>
@@ -207,7 +209,7 @@ void CDKGSessionManager::ProcessMessage(CNode* pfrom, const std::string& msg_typ
     {
         LOCK(cs_indexedQuorumsCache);
         if (indexedQuorumsCache.empty()) {
-            CLLMQUtils::InitQuorumsCache(indexedQuorumsCache);
+            CLLMQComplexUtils::InitQuorumsCache(indexedQuorumsCache);
         }
         indexedQuorumsCache[llmqType].get(quorumHash, quorumIndex);
     }
@@ -223,7 +225,7 @@ void CDKGSessionManager::ProcessMessage(CNode* pfrom, const std::string& msg_typ
             return;
         }
 
-        if (!CLLMQUtils::IsQuorumTypeEnabled(llmqType, pQuorumBaseBlockIndex->pprev)) {
+        if (!CLLMQComplexUtils::IsQuorumTypeEnabled(llmqType, pQuorumBaseBlockIndex->pprev)) {
             LOCK(cs_main);
             LogPrintf("CDKGSessionManager -- llmqType [%d] quorums aren't active\n", uint8_t(llmqType));
             Misbehaving(pfrom->GetId(), 100);
@@ -374,7 +376,7 @@ void CDKGSessionManager::WriteEncryptedContributions(Consensus::LLMQType llmqTyp
 bool CDKGSessionManager::GetVerifiedContributions(Consensus::LLMQType llmqType, const CBlockIndex* pQuorumBaseBlockIndex, const std::vector<bool>& validMembers, std::vector<uint16_t>& memberIndexesRet, std::vector<BLSVerificationVectorPtr>& vvecsRet, BLSSecretKeyVector& skContributionsRet) const
 {
     LOCK(contributionsCacheCs);
-    auto members = CLLMQUtils::GetAllQuorumMembers(llmqType, pQuorumBaseBlockIndex);
+    auto members = CLLMQComplexUtils::GetAllQuorumMembers(llmqType, pQuorumBaseBlockIndex);
 
     memberIndexesRet.clear();
     vvecsRet.clear();
@@ -408,7 +410,7 @@ bool CDKGSessionManager::GetVerifiedContributions(Consensus::LLMQType llmqType,
 
 bool CDKGSessionManager::GetEncryptedContributions(Consensus::LLMQType llmqType, const CBlockIndex* pQuorumBaseBlockIndex, const std::vector<bool>& validMembers, const uint256& nProTxHash, std::vector<CBLSIESEncryptedObject<CBLSSecretKey>>& vecRet) const
 {
-    auto members = CLLMQUtils::GetAllQuorumMembers(llmqType, pQuorumBaseBlockIndex);
+    auto members = CLLMQComplexUtils::GetAllQuorumMembers(llmqType, pQuorumBaseBlockIndex);
 
     vecRet.clear();
     vecRet.reserve(members.size());
diff --git a/src/llmq/dkgsessionmgr.h b/src/llmq/dkgsessionmgr.h
index 93783d086663..54dcf8ffd1f9 100644
--- a/src/llmq/dkgsessionmgr.h
+++ b/src/llmq/dkgsessionmgr.h
@@ -12,6 +12,7 @@
 
 class UniValue;
 class CBlockIndex;
+class CDBWrapper;
 
 namespace llmq
 {
diff --git a/src/llmq/quorums.cpp b/src/llmq/quorums.cpp
index e9729ad943f6..d20c12750735 100644
--- a/src/llmq/quorums.cpp
+++ b/src/llmq/quorums.cpp
@@ -8,9 +8,11 @@
 #include <llmq/dkgsession.h>
 #include <llmq/dkgsessionmgr.h>
 #include <llmq/utils.h>
+#include <llmq/complex_utils.h>
 
 #include <evo/specialtx.h>
 #include <evo/deterministicmns.h>
+#include <evo/evodb.h>
 
 #include <chainparams.h>
 #include <masternode/node.h>
@@ -21,6 +23,7 @@
 #include <univalue.h>
 #include <util/irange.h>
 #include <validation.h>
+#include <streams.h>
 
 #include <cxxtimer.hpp>
 
@@ -167,8 +170,8 @@ CQuorumManager::CQuorumManager(CEvoDB& _evoDb, CConnman& _connman, CBLSWorker& _
     blsWorker(_blsWorker),
     dkgManager(_dkgManager)
 {
-    CLLMQUtils::InitQuorumsCache(mapQuorumsCache);
-    CLLMQUtils::InitQuorumsCache(scanQuorumsCache);
+    CLLMQComplexUtils::InitQuorumsCache(mapQuorumsCache);
+    CLLMQComplexUtils::InitQuorumsCache(scanQuorumsCache);
 
     quorumThreadInterrupt.reset();
 }
@@ -294,7 +297,7 @@ void CQuorumManager::EnsureQuorumConnections(const Consensus::LLMQParams& llmqPa
     }
 
     for (const auto& quorum : lastQuorums) {
-        if (CLLMQUtils::EnsureQuorumConnections(llmqParams, quorum->m_quorum_base_block_index, connman, WITH_LOCK(activeMasternodeInfoCs, return activeMasternodeInfo.proTxHash))) {
+        if (CLLMQComplexUtils::EnsureQuorumConnections(llmqParams, quorum->m_quorum_base_block_index, connman, WITH_LOCK(activeMasternodeInfoCs, return activeMasternodeInfo.proTxHash))) {
             continue;
         }
         if (connmanQuorumsToDelete.count(quorum->qc->quorumHash) > 0) {
@@ -319,7 +322,7 @@ CQuorumPtr CQuorumManager::BuildQuorumFromCommitment(const Consensus::LLMQType l
     assert(qc->quorumHash == pQuorumBaseBlockIndex->GetBlockHash());
 
     auto quorum = std::make_shared<CQuorum>(llmq::GetLLMQParams(llmqType), blsWorker);
-    auto members = CLLMQUtils::GetAllQuorumMembers(qc->llmqType, pQuorumBaseBlockIndex);
+    auto members = CLLMQComplexUtils::GetAllQuorumMembers(qc->llmqType, pQuorumBaseBlockIndex);
 
     quorum->Init(std::move(qc), pQuorumBaseBlockIndex, minedBlockHash, members);
 
@@ -432,7 +435,7 @@ std::vector<CQuorumCPtr> CQuorumManager::ScanQuorums(Consensus::LLMQType llmqTyp
 
 std::vector<CQuorumCPtr> CQuorumManager::ScanQuorums(Consensus::LLMQType llmqType, const CBlockIndex* pindexStart, size_t nCountRequested) const
 {
-    if (pindexStart == nullptr || nCountRequested == 0 || !CLLMQUtils::IsQuorumTypeEnabled(llmqType, pindexStart)) {
+    if (pindexStart == nullptr || nCountRequested == 0 || !CLLMQComplexUtils::IsQuorumTypeEnabled(llmqType, pindexStart)) {
         return {};
     }
 
diff --git a/src/llmq/quorums.h b/src/llmq/quorums.h
index dbe3648912e2..c04762884dfb 100644
--- a/src/llmq/quorums.h
+++ b/src/llmq/quorums.h
@@ -10,16 +10,18 @@
 #include <saltedhasher.h>
 #include <threadinterrupt.h>
 #include <unordered_lru_cache.h>
+#include <util/time.h>
 
 #include <bls/bls.h>
 #include <bls/bls_worker.h>
 
-#include <evo/evodb.h>
-
 class CNode;
 
 class CConnman;
 class CBlockIndex;
+class CDataStream;
+
+class CEvoDB;
 
 class CDeterministicMN;
 using CDeterministicMNCPtr = std::shared_ptr<const CDeterministicMN>;
@@ -30,10 +32,6 @@ namespace llmq
 
 class CDKGSessionManager;
 
-// If true, we will connect to all new quorums and watch their communication
-static constexpr bool DEFAULT_WATCH_QUORUMS{false};
-
-
 /**
  * An object of this class represents a QGETDATA request or a QDATA response header
  */
diff --git a/src/llmq/signing.cpp b/src/llmq/signing.cpp
index e2c308568b57..f172ed8cac8d 100644
--- a/src/llmq/signing.cpp
+++ b/src/llmq/signing.cpp
@@ -7,6 +7,7 @@
 #include <llmq/quorums.h>
 #include <llmq/commitment.h>
 #include <llmq/utils.h>
+#include <llmq/complex_utils.h>
 #include <llmq/signing_shares.h>
 
 #include <bls/bls_batchverifier.h>
@@ -553,7 +554,7 @@ bool CSigningManager::GetRecoveredSigForGetData(const uint256& hash, CRecoveredS
     if (!db.GetRecoveredSigByHash(hash, ret)) {
         return false;
     }
-    if (!CLLMQUtils::IsQuorumActive(ret.getLlmqType(), ret.getQuorumHash())) {
+    if (!CLLMQComplexUtils::IsQuorumActive(ret.getLlmqType(), ret.getQuorumHash())) {
         // we don't want to propagate sigs from inactive quorums
         return false;
     }
@@ -621,7 +622,7 @@ bool CSigningManager::PreVerifyRecoveredSig(const CRecoveredSig& recoveredSig, b
                   recoveredSig.getQuorumHash().ToString());
         return false;
     }
-    if (!CLLMQUtils::IsQuorumActive(llmqType, quorum->qc->quorumHash)) {
+    if (!CLLMQComplexUtils::IsQuorumActive(llmqType, quorum->qc->quorumHash)) {
         return false;
     }
 
@@ -679,7 +680,7 @@ void CSigningManager::CollectPendingRecoveredSigsToVerify(
                     it = v.erase(it);
                     continue;
                 }
-                if (!CLLMQUtils::IsQuorumActive(llmqType, quorum->qc->quorumHash)) {
+                if (!CLLMQComplexUtils::IsQuorumActive(llmqType, quorum->qc->quorumHash)) {
                     LogPrint(BCLog::LLMQ, "CSigningManager::%s -- quorum %s not active anymore, node=%d\n", __func__,
                               recSig->getQuorumHash().ToString(), nodeId);
                     it = v.erase(it);
diff --git a/src/llmq/signing_shares.cpp b/src/llmq/signing_shares.cpp
index 03b2af47c24d..d29b1c8dce40 100644
--- a/src/llmq/signing_shares.cpp
+++ b/src/llmq/signing_shares.cpp
@@ -8,6 +8,7 @@
 #include <llmq/commitment.h>
 #include <llmq/signing.h>
 #include <llmq/utils.h>
+#include <llmq/complex_utils.h>
 
 #include <bls/bls_batchverifier.h>
 #include <chainparams.h>
@@ -460,7 +461,7 @@ void CSigSharesManager::ProcessMessageSigShare(NodeId fromId, const CSigShare& s
     if (!quorum) {
         return;
     }
-    if (!CLLMQUtils::IsQuorumActive(sigShare.getLlmqType(), quorum->qc->quorumHash)) {
+    if (!CLLMQComplexUtils::IsQuorumActive(sigShare.getLlmqType(), quorum->qc->quorumHash)) {
         // quorum is too old
         return;
     }
@@ -509,7 +510,7 @@ bool CSigSharesManager::PreVerifyBatchedSigShares(const CSigSharesNodeState::Ses
 {
     retBan = false;
 
-    if (!CLLMQUtils::IsQuorumActive(session.llmqType, session.quorum->qc->quorumHash)) {
+    if (!CLLMQComplexUtils::IsQuorumActive(session.llmqType, session.quorum->qc->quorumHash)) {
         // quorum is too old
         return false;
     }
@@ -1257,7 +1258,7 @@ void CSigSharesManager::Cleanup()
 
     // Find quorums which became inactive
     for (auto it = quorums.begin(); it != quorums.end(); ) {
-        if (CLLMQUtils::IsQuorumActive(it->first.first, it->first.second)) {
+        if (CLLMQComplexUtils::IsQuorumActive(it->first.first, it->first.second)) {
             it->second = quorumManager->GetQuorum(it->first.first, it->first.second);
             ++it;
         } else {
diff --git a/src/llmq/snapshot.cpp b/src/llmq/snapshot.cpp
index bdef5aa62736..bb0d308d9602 100644
--- a/src/llmq/snapshot.cpp
+++ b/src/llmq/snapshot.cpp
@@ -6,6 +6,7 @@
 
 #include <evo/simplifiedmns.h>
 #include <evo/specialtx.h>
+#include <evo/evodb.h>
 
 #include <llmq/blockprocessor.h>
 #include <llmq/commitment.h>
diff --git a/src/llmq/snapshot.h b/src/llmq/snapshot.h
index 0a046819afe4..c6cc719bc4ac 100644
--- a/src/llmq/snapshot.h
+++ b/src/llmq/snapshot.h
@@ -5,13 +5,13 @@
 #ifndef BITCOIN_LLMQ_SNAPSHOT_H
 #define BITCOIN_LLMQ_SNAPSHOT_H
 
-#include <evo/evodb.h>
 #include <evo/simplifiedmns.h>
 #include <llmq/params.h>
 #include <saltedhasher.h>
 #include <serialize.h>
 #include <univalue.h>
 #include <unordered_lru_cache.h>
+#include <sync.h>
 #include <util/irange.h>
 
 #include <optional>
@@ -19,6 +19,7 @@
 class CBlockIndex;
 class CDeterministicMN;
 class CDeterministicMNList;
+class CEvoDB;
 
 namespace llmq {
 //TODO use enum class (probably)
diff --git a/src/llmq/utils.cpp b/src/llmq/utils.cpp
index b588ad2cc066..d15fec396b72 100644
--- a/src/llmq/utils.cpp
+++ b/src/llmq/utils.cpp
@@ -4,25 +4,20 @@
 
 #include <llmq/utils.h>
 
-#include <llmq/quorums.h>
-//#include <llmq/blockprocessor.h>
-#include <llmq/commitment.h>
-#include <llmq/snapshot.h>
-
+#include <random.h>
+#include <versionbits.h>
+#include <sync.h>
 #include <bls/bls.h>
 #include <chainparams.h>
-#include <evo/deterministicmns.h>
-#include <evo/evodb.h>
-#include <masternode/meta.h>
-#include <net.h>
-#include <random.h>
 #include <spork.h>
-#include <timedata.h>
 #include <util/irange.h>
 #include <util/ranges.h>
-#include <validation.h>
-#include <versionbits.h>
+#include <uint256.h>
 
+#include <vector>
+#include <set>
+#include <map>
+#include <memory>
 #include <optional>
 
 namespace llmq
@@ -31,431 +26,6 @@ namespace llmq
 CCriticalSection cs_llmq_vbc;
 VersionBitsCache llmq_versionbitscache;
 
-void CLLMQUtils::PreComputeQuorumMembers(const CBlockIndex* pQuorumBaseBlockIndex)
-{
-    for (const Consensus::LLMQParams& params : CLLMQUtils::GetEnabledQuorumParams(pQuorumBaseBlockIndex->pprev)) {
-        if (llmq::CLLMQUtils::IsQuorumRotationEnabled(params.type, pQuorumBaseBlockIndex) && (pQuorumBaseBlockIndex->nHeight % params.dkgInterval == 0)) {
-            CLLMQUtils::GetAllQuorumMembers(params.type, pQuorumBaseBlockIndex);
-        }
-    }
-}
-
-std::vector<CDeterministicMNCPtr> CLLMQUtils::GetAllQuorumMembers(Consensus::LLMQType llmqType, const CBlockIndex* pQuorumBaseBlockIndex)
-{
-    static CCriticalSection cs_members;
-    static std::map<Consensus::LLMQType, unordered_lru_cache<uint256, std::vector<CDeterministicMNCPtr>, StaticSaltedHasher>> mapQuorumMembers GUARDED_BY(cs_members);
-    static CCriticalSection cs_indexed_members;
-    static std::map<Consensus::LLMQType, unordered_lru_cache<std::pair<uint256, int>, std::vector<CDeterministicMNCPtr>, StaticSaltedHasher>> mapIndexedQuorumMembers GUARDED_BY(cs_indexed_members);
-    if (!IsQuorumTypeEnabled(llmqType, pQuorumBaseBlockIndex->pprev)) {
-        return {};
-    }
-    std::vector<CDeterministicMNCPtr> quorumMembers;
-    {
-        LOCK(cs_members);
-        if (mapQuorumMembers.empty()) {
-            InitQuorumsCache(mapQuorumMembers);
-        }
-        if (mapQuorumMembers[llmqType].get(pQuorumBaseBlockIndex->GetBlockHash(), quorumMembers)) {
-            return quorumMembers;
-        }
-    }
-
-    if (CLLMQUtils::IsQuorumRotationEnabled(llmqType, pQuorumBaseBlockIndex)) {
-        if (LOCK(cs_indexed_members); mapIndexedQuorumMembers.empty()) {
-            InitQuorumsCache(mapIndexedQuorumMembers);
-        }
-        /*
-         * Quorums created with rotation are now created in a different way. All signingActiveQuorumCount are created during the period of dkgInterval.
-         * But they are not created exactly in the same block, they are spread overtime: one quorum in each block until all signingActiveQuorumCount are created.
-         * The new concept of quorumIndex is introduced in order to identify them.
-         * In every dkgInterval blocks (also called CycleQuorumBaseBlock), the spread quorum creation starts like this:
-         * For quorumIndex = 0 : signingActiveQuorumCount
-         * Quorum Q with quorumIndex is created at height CycleQuorumBaseBlock + quorumIndex
-         */
-
-        const Consensus::LLMQParams& llmqParams = GetLLMQParams(llmqType);
-        int quorumIndex = pQuorumBaseBlockIndex->nHeight % llmqParams.dkgInterval;
-        if (quorumIndex >= llmqParams.signingActiveQuorumCount) {
-            return {};
-        }
-        int cycleQuorumBaseHeight = pQuorumBaseBlockIndex->nHeight - quorumIndex;
-        const CBlockIndex* pCycleQuorumBaseBlockIndex = pQuorumBaseBlockIndex->GetAncestor(cycleQuorumBaseHeight);
-
-        /*
-         * Since mapQuorumMembers stores Quorum members per block hash, and we don't know yet the block hashes of blocks for all quorumIndexes (since these blocks are not created yet)
-         * We store them in a second cache mapIndexedQuorumMembers which stores them by {CycleQuorumBaseBlockHash, quorumIndex}
-         */
-            if (LOCK(cs_indexed_members); mapIndexedQuorumMembers[llmqType].get(std::pair(pCycleQuorumBaseBlockIndex->GetBlockHash(), quorumIndex), quorumMembers)) {
-                LOCK(cs_members);
-                mapQuorumMembers[llmqType].insert(pQuorumBaseBlockIndex->GetBlockHash(), quorumMembers);
-                return quorumMembers;
-            }
-
-        auto q = ComputeQuorumMembersByQuarterRotation(llmqType, pCycleQuorumBaseBlockIndex);
-        LOCK(cs_indexed_members);
-        for (int i = 0; i < static_cast<int>(q.size()); ++i) {
-            mapIndexedQuorumMembers[llmqType].insert(std::make_pair(pCycleQuorumBaseBlockIndex->GetBlockHash(), i), q[i]);
-        }
-
-        quorumMembers = q[quorumIndex];
-    } else {
-        quorumMembers = ComputeQuorumMembers(llmqType, pQuorumBaseBlockIndex);
-    }
-
-    LOCK(cs_members);
-    mapQuorumMembers[llmqType].insert(pQuorumBaseBlockIndex->GetBlockHash(), quorumMembers);
-    return quorumMembers;
-}
-
-std::vector<CDeterministicMNCPtr> CLLMQUtils::ComputeQuorumMembers(Consensus::LLMQType llmqType, const CBlockIndex* pQuorumBaseBlockIndex)
-{
-    auto allMns = deterministicMNManager->GetListForBlock(pQuorumBaseBlockIndex);
-    auto modifier = ::SerializeHash(std::make_pair(llmqType, pQuorumBaseBlockIndex->GetBlockHash()));
-    return allMns.CalculateQuorum(GetLLMQParams(llmqType).size, modifier);
-}
-
-std::vector<std::vector<CDeterministicMNCPtr>> CLLMQUtils::ComputeQuorumMembersByQuarterRotation(Consensus::LLMQType llmqType, const CBlockIndex* pCycleQuorumBaseBlockIndex)
-{
-    const Consensus::LLMQParams& llmqParams = GetLLMQParams(llmqType);
-
-    const int cycleLength = llmqParams.dkgInterval;
-    assert(pCycleQuorumBaseBlockIndex->nHeight % cycleLength == 0);
-
-    const CBlockIndex* pBlockHMinusCIndex = pCycleQuorumBaseBlockIndex->GetAncestor(pCycleQuorumBaseBlockIndex->nHeight - cycleLength);
-    const CBlockIndex* pBlockHMinus2CIndex = pCycleQuorumBaseBlockIndex->GetAncestor(pCycleQuorumBaseBlockIndex->nHeight - 2 * cycleLength);
-    const CBlockIndex* pBlockHMinus3CIndex = pCycleQuorumBaseBlockIndex->GetAncestor(pCycleQuorumBaseBlockIndex->nHeight - 3 * cycleLength);
-    LOCK(deterministicMNManager->cs);
-    const CBlockIndex* pWorkBlockIndex = pCycleQuorumBaseBlockIndex->GetAncestor(pCycleQuorumBaseBlockIndex->nHeight - 8);
-    auto allMns = deterministicMNManager->GetListForBlock(pWorkBlockIndex);
-    LogPrint(BCLog::LLMQ, "CLLMQUtils::ComputeQuorumMembersByQuarterRotation llmqType[%d] nHeight[%d] allMns[%d]\n", static_cast<int>(llmqType), pCycleQuorumBaseBlockIndex->nHeight, allMns.GetValidMNsCount());
-
-    PreviousQuorumQuarters previousQuarters = GetPreviousQuorumQuarterMembers(llmqParams, pBlockHMinusCIndex, pBlockHMinus2CIndex, pBlockHMinus3CIndex, pCycleQuorumBaseBlockIndex->nHeight);
-
-    auto nQuorums = size_t(llmqParams.signingActiveQuorumCount);
-    std::vector<std::vector<CDeterministicMNCPtr>> quorumMembers(nQuorums);
-
-    auto newQuarterMembers = CLLMQUtils::BuildNewQuorumQuarterMembers(llmqParams, pCycleQuorumBaseBlockIndex, previousQuarters);
-    //TODO Check if it is triggered from outside (P2P, block validation). Throwing an exception is probably a wiser choice
-    //assert (!newQuarterMembers.empty());
-
-    for (auto i = 0; i < nQuorums; ++i) {
-        std::stringstream ss;
-
-        ss << " 3Cmns[";
-        for (auto& m : previousQuarters.quarterHMinus3C[i]) {
-            ss << m->proTxHash.ToString().substr(0, 4) << " | ";
-        }
-        ss << " ] 2Cmns[";
-        for (auto& m : previousQuarters.quarterHMinus2C[i]) {
-            ss << m->proTxHash.ToString().substr(0, 4) << " | ";
-        }
-        ss << " ] Cmns[";
-        for (auto& m : previousQuarters.quarterHMinusC[i]) {
-            ss << m->proTxHash.ToString().substr(0, 4) << " | ";
-        }
-        ss << " ] new[";
-        for (auto& m : newQuarterMembers[i]) {
-            ss << m->proTxHash.ToString().substr(0, 4) << " | ";
-        }
-        ss << " ]";
-        LogPrint(BCLog::LLMQ, "QuarterComposition h[%d] i[%d]:%s\n", pCycleQuorumBaseBlockIndex->nHeight, i, ss.str());
-    }
-
-    for (auto i = 0; i < nQuorums; ++i) {
-        for (auto& m : previousQuarters.quarterHMinus3C[i]) {
-            quorumMembers[i].push_back(std::move(m));
-        }
-        for (auto& m : previousQuarters.quarterHMinus2C[i]) {
-            quorumMembers[i].push_back(std::move(m));
-        }
-        for (auto& m : previousQuarters.quarterHMinusC[i]) {
-            quorumMembers[i].push_back(std::move(m));
-        }
-        for (auto& m : newQuarterMembers[i]) {
-            quorumMembers[i].push_back(std::move(m));
-        }
-
-        std::stringstream ss;
-        ss << " [";
-        for (auto& m : quorumMembers[i]) {
-            ss << m->proTxHash.ToString().substr(0, 4) << " | ";
-        }
-        ss << "]";
-        LogPrint(BCLog::LLMQ, "QuorumComposition h[%d] i[%d]:%s\n", pCycleQuorumBaseBlockIndex->nHeight, i, ss.str());
-    }
-
-    return quorumMembers;
-}
-
-PreviousQuorumQuarters CLLMQUtils::GetPreviousQuorumQuarterMembers(const Consensus::LLMQParams& llmqParams, const CBlockIndex* pBlockHMinusCIndex, const CBlockIndex* pBlockHMinus2CIndex, const CBlockIndex* pBlockHMinus3CIndex, int nHeight)
-{
-    auto nQuorums = size_t(llmqParams.signingActiveQuorumCount);
-    PreviousQuorumQuarters quarters(nQuorums);
-
-    std::optional<llmq::CQuorumSnapshot> quSnapshotHMinusC = quorumSnapshotManager->GetSnapshotForBlock(llmqParams.type, pBlockHMinusCIndex);
-    if (quSnapshotHMinusC.has_value()) {
-        quarters.quarterHMinusC = CLLMQUtils::GetQuorumQuarterMembersBySnapshot(llmqParams, pBlockHMinusCIndex, quSnapshotHMinusC.value(), nHeight);
-        //TODO Check if it is triggered from outside (P2P, block validation). Throwing an exception is probably a wiser choice
-        //assert (!quarterHMinusC.empty());
-
-        std::optional<llmq::CQuorumSnapshot> quSnapshotHMinus2C = quorumSnapshotManager->GetSnapshotForBlock(llmqParams.type, pBlockHMinus2CIndex);
-        if (quSnapshotHMinus2C.has_value()) {
-            quarters.quarterHMinus2C = CLLMQUtils::GetQuorumQuarterMembersBySnapshot(llmqParams, pBlockHMinus2CIndex, quSnapshotHMinus2C.value(), nHeight);
-            //TODO Check if it is triggered from outside (P2P, block validation). Throwing an exception is probably a wiser choice
-            //assert (!quarterHMinusC.empty());
-
-            std::optional<llmq::CQuorumSnapshot> quSnapshotHMinus3C = quorumSnapshotManager->GetSnapshotForBlock(llmqParams.type, pBlockHMinus3CIndex);
-            if (quSnapshotHMinus3C.has_value()) {
-                quarters.quarterHMinus3C = CLLMQUtils::GetQuorumQuarterMembersBySnapshot(llmqParams, pBlockHMinus3CIndex, quSnapshotHMinus3C.value(), nHeight);
-                //TODO Check if it is triggered from outside (P2P, block validation). Throwing an exception is probably a wiser choice
-                //assert (!quarterHMinusC.empty());
-            }
-        }
-    }
-
-    return quarters;
-}
-
-std::vector<std::vector<CDeterministicMNCPtr>> CLLMQUtils::BuildNewQuorumQuarterMembers(const Consensus::LLMQParams& llmqParams, const CBlockIndex* pQuorumBaseBlockIndex, const PreviousQuorumQuarters& previousQuarters)
-{
-    auto nQuorums = size_t(llmqParams.signingActiveQuorumCount);
-    std::vector<std::vector<CDeterministicMNCPtr>> quarterQuorumMembers(nQuorums);
-
-    auto quorumSize = size_t(llmqParams.size);
-    auto quarterSize = quorumSize / 4;
-    const CBlockIndex* pWorkBlockIndex = pQuorumBaseBlockIndex->GetAncestor(pQuorumBaseBlockIndex->nHeight - 8);
-    auto modifier = ::SerializeHash(std::make_pair(llmqParams.type, pWorkBlockIndex->GetBlockHash()));
-
-    LOCK(deterministicMNManager->cs);
-    auto allMns = deterministicMNManager->GetListForBlock(pWorkBlockIndex);
-
-    if (allMns.GetValidMNsCount() < quarterSize) return quarterQuorumMembers;
-
-    auto MnsUsedAtH = CDeterministicMNList();
-    auto MnsNotUsedAtH = CDeterministicMNList();
-    std::vector<CDeterministicMNList> MnsUsedAtHIndexed(nQuorums);
-
-    for (auto i = 0; i < nQuorums; ++i) {
-        for (const auto& mn : previousQuarters.quarterHMinusC[i]) {
-            try {
-                MnsUsedAtH.AddMN(mn);
-            } catch (std::runtime_error& e) {
-            }
-            try {
-                MnsUsedAtHIndexed[i].AddMN(mn);
-            } catch (std::runtime_error& e) {
-            }
-        }
-        for (const auto& mn : previousQuarters.quarterHMinus2C[i]) {
-            try {
-                MnsUsedAtH.AddMN(mn);
-            } catch (std::runtime_error& e) {
-            }
-            try {
-                MnsUsedAtHIndexed[i].AddMN(mn);
-            } catch (std::runtime_error& e) {
-            }
-        }
-        for (const auto& mn : previousQuarters.quarterHMinus3C[i]) {
-            try {
-                MnsUsedAtH.AddMN(mn);
-            } catch (std::runtime_error& e) {
-            }
-            try {
-                MnsUsedAtHIndexed[i].AddMN(mn);
-            } catch (std::runtime_error& e) {
-            }
-        }
-    }
-
-    allMns.ForEachMNShared(true, [&MnsUsedAtH, &MnsNotUsedAtH](const CDeterministicMNCPtr& dmn) {
-        if (!MnsUsedAtH.HasMN(dmn->proTxHash)) {
-            try {
-                MnsNotUsedAtH.AddMN(dmn);
-            } catch (std::runtime_error& e) {
-            }
-        }
-    });
-
-    auto sortedMnsUsedAtHM = MnsUsedAtH.CalculateQuorum(MnsUsedAtH.GetAllMNsCount(), modifier);
-    auto sortedMnsNotUsedAtH = MnsNotUsedAtH.CalculateQuorum(MnsNotUsedAtH.GetAllMNsCount(), modifier);
-    auto sortedCombinedMnsList = std::move(sortedMnsNotUsedAtH);
-    for (auto& m : sortedMnsUsedAtHM) {
-        sortedCombinedMnsList.push_back(std::move(m));
-    }
-
-    std::stringstream ss;
-    ss << " [";
-    for (auto& m : sortedCombinedMnsList) {
-        ss << m->proTxHash.ToString().substr(0, 4) << " | ";
-    }
-    ss << "]";
-    LogPrint(BCLog::LLMQ, "BuildNewQuorumQuarterMembers h[%d] sortedCombinedMnsList:%s\n", pQuorumBaseBlockIndex->nHeight, ss.str());
-
-    std::vector<int> skipList;
-    int firstSkippedIndex = 0;
-    auto idx = 0;
-    for (auto i = 0; i < nQuorums; ++i) {
-        auto usedMNsCount = MnsUsedAtHIndexed[i].GetAllMNsCount();
-        while (quarterQuorumMembers[i].size() < quarterSize && (usedMNsCount + quarterQuorumMembers[i].size() < sortedCombinedMnsList.size())) {
-            if (!MnsUsedAtHIndexed[i].HasMN(sortedCombinedMnsList[idx]->proTxHash)) {
-                quarterQuorumMembers[i].push_back(sortedCombinedMnsList[idx]);
-            } else {
-                if (firstSkippedIndex == 0) {
-                    firstSkippedIndex = idx;
-                    skipList.push_back(idx);
-                } else {
-                    skipList.push_back(idx - firstSkippedIndex);
-                }
-            }
-            if (++idx == sortedCombinedMnsList.size()) {
-                idx = 0;
-            }
-        }
-    }
-
-    CQuorumSnapshot quorumSnapshot = {};
-
-    CLLMQUtils::BuildQuorumSnapshot(llmqParams, allMns, MnsUsedAtH, sortedCombinedMnsList, quorumSnapshot, pQuorumBaseBlockIndex->nHeight, skipList, pQuorumBaseBlockIndex);
-
-    quorumSnapshotManager->StoreSnapshotForBlock(llmqParams.type, pQuorumBaseBlockIndex, quorumSnapshot);
-
-    return quarterQuorumMembers;
-}
-
-void CLLMQUtils::BuildQuorumSnapshot(const Consensus::LLMQParams& llmqParams, const CDeterministicMNList& mnAtH, const CDeterministicMNList& mnUsedAtH, std::vector<CDeterministicMNCPtr>& sortedCombinedMns, CQuorumSnapshot& quorumSnapshot, int nHeight, std::vector<int>& skipList, const CBlockIndex* pQuorumBaseBlockIndex)
-{
-    quorumSnapshot.activeQuorumMembers.resize(mnAtH.GetAllMNsCount());
-    const CBlockIndex* pWorkBlockIndex = pQuorumBaseBlockIndex->GetAncestor(pQuorumBaseBlockIndex->nHeight - 8);
-    auto modifier = ::SerializeHash(std::make_pair(llmqParams.type, pWorkBlockIndex->GetBlockHash()));
-    auto sortedAllMns = mnAtH.CalculateQuorum(mnAtH.GetAllMNsCount(), modifier);
-
-    std::fill(quorumSnapshot.activeQuorumMembers.begin(),
-              quorumSnapshot.activeQuorumMembers.end(),
-              false);
-    size_t index = {};
-    for (const auto& dmn : sortedAllMns) {
-        if (mnUsedAtH.HasMN(dmn->proTxHash)) {
-            quorumSnapshot.activeQuorumMembers[index] = true;
-        }
-        index++;
-    }
-
-    if (skipList.empty()) {
-        quorumSnapshot.mnSkipListMode = SnapshotSkipMode::MODE_NO_SKIPPING;
-        quorumSnapshot.mnSkipList.clear();
-    } else {
-        quorumSnapshot.mnSkipListMode = SnapshotSkipMode::MODE_SKIPPING_ENTRIES;
-        quorumSnapshot.mnSkipList = std::move(skipList);
-    }
-}
-
-std::vector<std::vector<CDeterministicMNCPtr>> CLLMQUtils::GetQuorumQuarterMembersBySnapshot(const Consensus::LLMQParams& llmqParams, const CBlockIndex* pQuorumBaseBlockIndex, const llmq::CQuorumSnapshot& snapshot, int nHeight)
-{
-    std::vector<CDeterministicMNCPtr> sortedCombinedMns;
-    {
-        const CBlockIndex* pWorkBlockIndex = pQuorumBaseBlockIndex->GetAncestor(pQuorumBaseBlockIndex->nHeight - 8);
-        const auto modifier = ::SerializeHash(std::make_pair(llmqParams.type, pWorkBlockIndex->GetBlockHash()));
-        const auto [MnsUsedAtH, MnsNotUsedAtH] = CLLMQUtils::GetMNUsageBySnapshot(llmqParams.type, pQuorumBaseBlockIndex, snapshot, nHeight);
-        // the list begins with all the unused MNs
-        auto sortedMnsNotUsedAtH = MnsNotUsedAtH.CalculateQuorum(MnsNotUsedAtH.GetAllMNsCount(), modifier);
-        sortedCombinedMns = std::move(sortedMnsNotUsedAtH);
-        // Now add the already used MNs to the end of the list
-        auto sortedMnsUsedAtH = MnsUsedAtH.CalculateQuorum(MnsUsedAtH.GetAllMNsCount(), modifier);
-        std::move(sortedMnsUsedAtH.begin(), sortedMnsUsedAtH.end(), std::back_inserter(sortedCombinedMns));
-    }
-
-    auto numQuorums = size_t(llmqParams.signingActiveQuorumCount);
-    auto quorumSize = size_t(llmqParams.size);
-    auto quarterSize = quorumSize / 4;
-
-    std::vector<std::vector<CDeterministicMNCPtr>> quarterQuorumMembers(numQuorums);
-
-    if (sortedCombinedMns.empty()) return quarterQuorumMembers;
-
-    switch (snapshot.mnSkipListMode) {
-        case SnapshotSkipMode::MODE_NO_SKIPPING:
-        {
-            auto itm = sortedCombinedMns.begin();
-            for (auto i = 0; i < llmqParams.signingActiveQuorumCount; ++i) {
-                while (quarterQuorumMembers[i].size() < quarterSize) {
-                    quarterQuorumMembers[i].push_back(*itm);
-                    itm++;
-                    if (itm == sortedCombinedMns.end()) {
-                        itm = sortedCombinedMns.begin();
-                    }
-                }
-            }
-            return quarterQuorumMembers;
-        }
-        case SnapshotSkipMode::MODE_SKIPPING_ENTRIES: // List holds entries to be skipped
-        {
-            size_t first_entry_index{0};
-            std::vector<int> processesdSkipList;
-            for (const auto& s : snapshot.mnSkipList) {
-                if (first_entry_index == 0) {
-                    first_entry_index = s;
-                    processesdSkipList.push_back(s);
-                } else {
-                    processesdSkipList.push_back(first_entry_index + s);
-                }
-            }
-
-            auto idx = 0;
-            auto itsk = processesdSkipList.begin();
-            for (auto i = 0; i < llmqParams.signingActiveQuorumCount; ++i) {
-                while (quarterQuorumMembers[i].size() < quarterSize) {
-                    if (itsk != processesdSkipList.end() && idx == *itsk) {
-                        itsk++;
-                    } else {
-                        quarterQuorumMembers[i].push_back(sortedCombinedMns[idx]);
-                    }
-                    idx++;
-                    if (idx == sortedCombinedMns.size()) {
-                        idx = 0;
-                    }
-                }
-            }
-            return quarterQuorumMembers;
-        }
-        case SnapshotSkipMode::MODE_NO_SKIPPING_ENTRIES: // List holds entries to be kept
-        case SnapshotSkipMode::MODE_ALL_SKIPPED: // Every node was skipped. Returning empty quarterQuorumMembers
-        default:
-            return quarterQuorumMembers;
-    }
-}
-
-std::pair<CDeterministicMNList, CDeterministicMNList> CLLMQUtils::GetMNUsageBySnapshot(Consensus::LLMQType llmqType, const CBlockIndex* pQuorumBaseBlockIndex, const llmq::CQuorumSnapshot& snapshot, int nHeight)
-{
-    CDeterministicMNList usedMNs;
-    CDeterministicMNList nonUsedMNs;
-    LOCK(deterministicMNManager->cs);
-
-    const CBlockIndex* pWorkBlockIndex = pQuorumBaseBlockIndex->GetAncestor(pQuorumBaseBlockIndex->nHeight - 8);
-    auto modifier = ::SerializeHash(std::make_pair(llmqType, pWorkBlockIndex->GetBlockHash()));
-
-    auto Mns = deterministicMNManager->GetListForBlock(pWorkBlockIndex);
-    auto sortedAllMns = Mns.CalculateQuorum(Mns.GetAllMNsCount(), modifier);
-
-    size_t i{0};
-    for (const auto& dmn : sortedAllMns) {
-        if (snapshot.activeQuorumMembers[i]) {
-            try {
-                usedMNs.AddMN(dmn);
-            } catch (std::runtime_error& e) {
-            }
-        } else {
-            try {
-                nonUsedMNs.AddMN(dmn);
-            } catch (std::runtime_error& e) {
-            }
-        }
-        i++;
-    }
-
-    return std::make_pair(usedMNs, nonUsedMNs);
-}
-
 uint256 CLLMQUtils::BuildCommitmentHash(Consensus::LLMQType llmqType, const uint256& blockHash, const std::vector<bool>& validMembers, const CBLSPublicKey& pubKey, const uint256& vvecHash)
 {
     CHashWriter hw(SER_NETWORK, 0);
@@ -515,14 +85,6 @@ bool CLLMQUtils::IsQuorumRotationEnabled(Consensus::LLMQType llmqType, const CBl
     return CLLMQUtils::IsDIP0024Active(pindex->GetAncestor(cycleQuorumBaseHeight - 1));
 }
 
-Consensus::LLMQType CLLMQUtils::GetInstantSendLLMQType(const CBlockIndex* pindex)
-{
-    if (IsDIP0024Active(pindex) && !quorumManager->ScanQuorums(Params().GetConsensus().llmqTypeDIP0024InstantSend, pindex, 1).empty()) {
-        return Params().GetConsensus().llmqTypeDIP0024InstantSend;
-    }
-    return Params().GetConsensus().llmqTypeInstantSend;
-}
-
 Consensus::LLMQType CLLMQUtils::GetInstantSendLLMQType(bool deterministic)
 {
     return deterministic ? Params().GetConsensus().llmqTypeDIP0024InstantSend : Params().GetConsensus().llmqTypeInstantSend;
@@ -558,264 +120,6 @@ uint256 CLLMQUtils::DeterministicOutboundConnection(const uint256& proTxHash1, c
     return proTxHash2;
 }
 
-std::set<uint256> CLLMQUtils::GetQuorumConnections(const Consensus::LLMQParams& llmqParams, const CBlockIndex* pQuorumBaseBlockIndex, const uint256& forMember, bool onlyOutbound)
-{
-    if (IsAllMembersConnectedEnabled(llmqParams.type)) {
-        auto mns = GetAllQuorumMembers(llmqParams.type, pQuorumBaseBlockIndex);
-        std::set<uint256> result;
-
-        for (const auto& dmn : mns) {
-            if (dmn->proTxHash == forMember) {
-                continue;
-            }
-            // Determine which of the two MNs (forMember vs dmn) should initiate the outbound connection and which
-            // one should wait for the inbound connection. We do this in a deterministic way, so that even when we
-            // end up with both connecting to each other, we know which one to disconnect
-            uint256 deterministicOutbound = DeterministicOutboundConnection(forMember, dmn->proTxHash);
-            if (!onlyOutbound || deterministicOutbound == dmn->proTxHash) {
-                result.emplace(dmn->proTxHash);
-            }
-        }
-        return result;
-    } else {
-        return GetQuorumRelayMembers(llmqParams, pQuorumBaseBlockIndex, forMember, onlyOutbound);
-    }
-}
-
-std::set<uint256> CLLMQUtils::GetQuorumRelayMembers(const Consensus::LLMQParams& llmqParams, const CBlockIndex* pQuorumBaseBlockIndex, const uint256& forMember, bool onlyOutbound)
-{
-    auto mns = GetAllQuorumMembers(llmqParams.type, pQuorumBaseBlockIndex);
-    std::set<uint256> result;
-
-    auto calcOutbound = [&](size_t i, const uint256& proTxHash) {
-        if (mns.size() == 1) {
-            // No outbound connections are needed when there is one MN only.
-            // Also note that trying to calculate results via the algorithm below
-            // would result in an endless loop.
-            return std::set<uint256>();
-        }
-        // Relay to nodes at indexes (i+2^k)%n, where
-        //   k: 0..max(1, floor(log2(n-1))-1)
-        //   n: size of the quorum/ring
-        std::set<uint256> r;
-        int gap = 1;
-        int gap_max = (int)mns.size() - 1;
-        int k = 0;
-        while ((gap_max >>= 1) || k <= 1) {
-            size_t idx = (i + gap) % mns.size();
-            const auto& otherDmn = mns[idx];
-            if (otherDmn->proTxHash == proTxHash) {
-                continue;
-            }
-            r.emplace(otherDmn->proTxHash);
-            gap <<= 1;
-            k++;
-        }
-        return r;
-    };
-
-    for (const auto i : irange::range(mns.size())) {
-        const auto& dmn = mns[i];
-        if (dmn->proTxHash == forMember) {
-            auto r = calcOutbound(i, dmn->proTxHash);
-            result.insert(r.begin(), r.end());
-        } else if (!onlyOutbound) {
-            auto r = calcOutbound(i, dmn->proTxHash);
-            if (r.count(forMember)) {
-                result.emplace(dmn->proTxHash);
-            }
-        }
-    }
-
-    return result;
-}
-
-std::set<size_t> CLLMQUtils::CalcDeterministicWatchConnections(Consensus::LLMQType llmqType, const CBlockIndex* pQuorumBaseBlockIndex, size_t memberCount, size_t connectionCount)
-{
-    static uint256 qwatchConnectionSeed;
-    static std::atomic<bool> qwatchConnectionSeedGenerated{false};
-    static CCriticalSection qwatchConnectionSeedCs;
-    if (!qwatchConnectionSeedGenerated) {
-        LOCK(qwatchConnectionSeedCs);
-        qwatchConnectionSeed = GetRandHash();
-        qwatchConnectionSeedGenerated = true;
-    }
-
-    std::set<size_t> result;
-    uint256 rnd = qwatchConnectionSeed;
-    for ([[maybe_unused]] const auto _ : irange::range(connectionCount)) {
-        rnd = ::SerializeHash(std::make_pair(rnd, std::make_pair(llmqType, pQuorumBaseBlockIndex->GetBlockHash())));
-        result.emplace(rnd.GetUint64(0) % memberCount);
-    }
-    return result;
-}
-
-bool CLLMQUtils::EnsureQuorumConnections(const Consensus::LLMQParams& llmqParams, const CBlockIndex* pQuorumBaseBlockIndex, CConnman& connman, const uint256& myProTxHash)
-{
-    auto members = GetAllQuorumMembers(llmqParams.type, pQuorumBaseBlockIndex);
-    bool isMember = std::find_if(members.begin(), members.end(), [&](const auto& dmn) { return dmn->proTxHash == myProTxHash; }) != members.end();
-
-    if (!isMember && !CLLMQUtils::IsWatchQuorumsEnabled()) {
-        return false;
-    }
-
-    std::set<uint256> connections;
-    std::set<uint256> relayMembers;
-    if (isMember) {
-        connections = CLLMQUtils::GetQuorumConnections(llmqParams, pQuorumBaseBlockIndex, myProTxHash, true);
-        relayMembers = CLLMQUtils::GetQuorumRelayMembers(llmqParams, pQuorumBaseBlockIndex, myProTxHash, true);
-    } else {
-        auto cindexes = CLLMQUtils::CalcDeterministicWatchConnections(llmqParams.type, pQuorumBaseBlockIndex, members.size(), 1);
-        for (auto idx : cindexes) {
-            connections.emplace(members[idx]->proTxHash);
-        }
-        relayMembers = connections;
-    }
-    if (!connections.empty()) {
-        if (!connman.HasMasternodeQuorumNodes(llmqParams.type, pQuorumBaseBlockIndex->GetBlockHash()) && LogAcceptCategory(BCLog::LLMQ)) {
-            auto mnList = deterministicMNManager->GetListAtChainTip();
-            std::string debugMsg = strprintf("CLLMQUtils::%s -- adding masternodes quorum connections for quorum %s:\n", __func__, pQuorumBaseBlockIndex->GetBlockHash().ToString());
-            for (auto& c : connections) {
-                auto dmn = mnList.GetValidMN(c);
-                if (!dmn) {
-                    debugMsg += strprintf("  %s (not in valid MN set anymore)\n", c.ToString());
-                } else {
-                    debugMsg += strprintf("  %s (%s)\n", c.ToString(), dmn->pdmnState->addr.ToString(false));
-                }
-            }
-            LogPrint(BCLog::NET_NETCONN, debugMsg.c_str()); /* Continued */
-        }
-        connman.SetMasternodeQuorumNodes(llmqParams.type, pQuorumBaseBlockIndex->GetBlockHash(), connections);
-    }
-    if (!relayMembers.empty()) {
-        connman.SetMasternodeQuorumRelayMembers(llmqParams.type, pQuorumBaseBlockIndex->GetBlockHash(), relayMembers);
-    }
-    return true;
-}
-
-void CLLMQUtils::AddQuorumProbeConnections(const Consensus::LLMQParams& llmqParams, const CBlockIndex *pQuorumBaseBlockIndex, CConnman& connman, const uint256 &myProTxHash)
-{
-    if (!CLLMQUtils::IsQuorumPoseEnabled(llmqParams.type)) {
-        return;
-    }
-
-    auto members = GetAllQuorumMembers(llmqParams.type, pQuorumBaseBlockIndex);
-    auto curTime = GetAdjustedTime();
-
-    std::set<uint256> probeConnections;
-    for (const auto& dmn : members) {
-        if (dmn->proTxHash == myProTxHash) {
-            continue;
-        }
-        auto lastOutbound = mmetaman.GetMetaInfo(dmn->proTxHash)->GetLastOutboundSuccess();
-        // re-probe after 50 minutes so that the "good connection" check in the DKG doesn't fail just because we're on
-        // the brink of timeout
-        if (curTime - lastOutbound > 50 * 60) {
-            probeConnections.emplace(dmn->proTxHash);
-        }
-    }
-
-    if (!probeConnections.empty()) {
-        if (LogAcceptCategory(BCLog::LLMQ)) {
-            auto mnList = deterministicMNManager->GetListAtChainTip();
-            std::string debugMsg = strprintf("CLLMQUtils::%s -- adding masternodes probes for quorum %s:\n", __func__, pQuorumBaseBlockIndex->GetBlockHash().ToString());
-            for (auto& c : probeConnections) {
-                auto dmn = mnList.GetValidMN(c);
-                if (!dmn) {
-                    debugMsg += strprintf("  %s (not in valid MN set anymore)\n", c.ToString());
-                } else {
-                    debugMsg += strprintf("  %s (%s)\n", c.ToString(), dmn->pdmnState->addr.ToString(false));
-                }
-            }
-            LogPrint(BCLog::NET_NETCONN, debugMsg.c_str()); /* Continued */
-        }
-        connman.AddPendingProbeConnections(probeConnections);
-    }
-}
-
-bool CLLMQUtils::IsQuorumActive(Consensus::LLMQType llmqType, const uint256& quorumHash)
-{
-    // sig shares and recovered sigs are only accepted from recent/active quorums
-    // we allow one more active quorum as specified in consensus, as otherwise there is a small window where things could
-    // fail while we are on the brink of a new quorum
-    auto quorums = quorumManager->ScanQuorums(llmqType, GetLLMQParams(llmqType).signingActiveQuorumCount + 1);
-    return ranges::any_of(quorums, [&quorumHash](const auto& q){ return q->qc->quorumHash == quorumHash; });
-}
-
-bool CLLMQUtils::IsQuorumTypeEnabled(Consensus::LLMQType llmqType, const CBlockIndex* pindex)
-{
-    return IsQuorumTypeEnabledInternal(llmqType, pindex, std::nullopt, std::nullopt);
-}
-
-bool CLLMQUtils::IsQuorumTypeEnabledInternal(Consensus::LLMQType llmqType, const CBlockIndex* pindex, std::optional<bool> optDIP0024IsActive, std::optional<bool> optHaveDIP0024Quorums)
-{
-    const Consensus::Params& consensusParams = Params().GetConsensus();
-
-    switch (llmqType)
-    {
-        case Consensus::LLMQType::LLMQ_TEST_INSTANTSEND:
-        case Consensus::LLMQType::LLMQ_50_60: {
-            bool fDIP0024IsActive = optDIP0024IsActive.has_value() ? *optDIP0024IsActive : CLLMQUtils::IsDIP0024Active(pindex);
-            if (fDIP0024IsActive) {
-                bool fHaveDIP0024Quorums = optHaveDIP0024Quorums.has_value() ? *optHaveDIP0024Quorums
-                                                                             : !quorumManager->ScanQuorums(
-                                consensusParams.llmqTypeDIP0024InstantSend, pindex, 1).empty();
-                if (fHaveDIP0024Quorums) {
-                    return false;
-                }
-            }
-            break;
-        }
-        case Consensus::LLMQType::LLMQ_TEST:
-        case Consensus::LLMQType::LLMQ_400_60:
-        case Consensus::LLMQType::LLMQ_400_85:
-            break;
-        case Consensus::LLMQType::LLMQ_100_67:
-        case Consensus::LLMQType::LLMQ_TEST_V17:
-            if (LOCK(cs_llmq_vbc); VersionBitsState(pindex, consensusParams, Consensus::DEPLOYMENT_DIP0020, llmq_versionbitscache) != ThresholdState::ACTIVE) {
-                return false;
-            }
-            break;
-        case Consensus::LLMQType::LLMQ_60_75:
-        case Consensus::LLMQType::LLMQ_TEST_DIP0024: {
-            bool fDIP0024IsActive = optDIP0024IsActive.has_value() ? *optDIP0024IsActive : CLLMQUtils::IsDIP0024Active(pindex);
-            if (!fDIP0024IsActive) {
-                return false;
-            }
-            break;
-        }
-        case Consensus::LLMQType::LLMQ_DEVNET:
-            break;
-        default:
-            throw std::runtime_error(strprintf("%s: Unknown LLMQ type %d", __func__, static_cast<uint8_t>(llmqType)));
-    }
-
-    return true;
-}
-
-std::vector<Consensus::LLMQType> CLLMQUtils::GetEnabledQuorumTypes(const CBlockIndex* pindex)
-{
-    std::vector<Consensus::LLMQType> ret;
-    ret.reserve(Params().GetConsensus().llmqs.size());
-    for (const auto& params : Params().GetConsensus().llmqs) {
-        if (IsQuorumTypeEnabled(params.type, pindex)) {
-            ret.push_back(params.type);
-        }
-    }
-    return ret;
-}
-
-std::vector<std::reference_wrapper<const Consensus::LLMQParams>> CLLMQUtils::GetEnabledQuorumParams(const CBlockIndex* pindex)
-{
-    std::vector<std::reference_wrapper<const Consensus::LLMQParams>> ret;
-    ret.reserve(Params().GetConsensus().llmqs.size());
-
-    std::copy_if(Params().GetConsensus().llmqs.begin(), Params().GetConsensus().llmqs.end(), std::back_inserter(ret),
-                 [&pindex](const auto& params){return IsQuorumTypeEnabled(params.type, pindex);});
-
-    return ret;
-}
-
 bool CLLMQUtils::QuorumDataRecoveryEnabled()
 {
     return gArgs.GetBoolArg("-llmq-data-recovery", DEFAULT_ENABLE_QUORUM_DATA_RECOVERY);
@@ -874,18 +178,8 @@ std::map<Consensus::LLMQType, QvvecSyncMode> CLLMQUtils::GetEnabledQuorumVvecSyn
     return mapQuorumVvecSyncEntries;
 }
 
-template <typename CacheType>
-void CLLMQUtils::InitQuorumsCache(CacheType& cache)
-{
-    for (auto& llmq : Params().GetConsensus().llmqs) {
-        cache.emplace(std::piecewise_construct, std::forward_as_tuple(llmq.type),
-                      std::forward_as_tuple(llmq.signingActiveQuorumCount + 1));
-    }
-}
-template void CLLMQUtils::InitQuorumsCache<std::map<Consensus::LLMQType, unordered_lru_cache<uint256, bool, StaticSaltedHasher>>>(std::map<Consensus::LLMQType, unordered_lru_cache<uint256, bool, StaticSaltedHasher>>& cache);
-template void CLLMQUtils::InitQuorumsCache<std::map<Consensus::LLMQType, unordered_lru_cache<uint256, std::vector<CQuorumCPtr>, StaticSaltedHasher>>>(std::map<Consensus::LLMQType, unordered_lru_cache<uint256, std::vector<CQuorumCPtr>, StaticSaltedHasher>>& cache);
-template void CLLMQUtils::InitQuorumsCache<std::map<Consensus::LLMQType, unordered_lru_cache<uint256, std::shared_ptr<llmq::CQuorum>, StaticSaltedHasher, 0ul, 0ul>, std::less<Consensus::LLMQType>, std::allocator<std::pair<Consensus::LLMQType const, unordered_lru_cache<uint256, std::shared_ptr<llmq::CQuorum>, StaticSaltedHasher, 0ul, 0ul>>>>>(std::map<Consensus::LLMQType, unordered_lru_cache<uint256, std::shared_ptr<llmq::CQuorum>, StaticSaltedHasher, 0ul, 0ul>, std::less<Consensus::LLMQType>, std::allocator<std::pair<Consensus::LLMQType const, unordered_lru_cache<uint256, std::shared_ptr<llmq::CQuorum>, StaticSaltedHasher, 0ul, 0ul>>>>&);
-template void CLLMQUtils::InitQuorumsCache<std::map<Consensus::LLMQType, unordered_lru_cache<uint256, int, StaticSaltedHasher>>>(std::map<Consensus::LLMQType, unordered_lru_cache<uint256, int, StaticSaltedHasher>>& cache);
+class CQuorum;
+using CQuorumCPtr = std::shared_ptr<const CQuorum>;
 
 const Consensus::LLMQParams& GetLLMQParams(Consensus::LLMQType llmqType)
 {
diff --git a/src/llmq/utils.h b/src/llmq/utils.h
index 64ca37ef93e1..4e62409db732 100644
--- a/src/llmq/utils.h
+++ b/src/llmq/utils.h
@@ -5,16 +5,12 @@
 #ifndef BITCOIN_LLMQ_UTILS_H
 #define BITCOIN_LLMQ_UTILS_H
 
-#include <consensus/params.h>
-#include <util/irange.h>
-
-#include <dbwrapper.h>
 #include <random.h>
-#include <set>
+#include <versionbits.h>
 #include <sync.h>
-#include <optional>
+
 #include <vector>
-#include <versionbits.h>
+#include <memory>
 
 class CConnman;
 class CBlockIndex;
@@ -26,6 +22,10 @@ class CBLSPublicKey;
 namespace llmq
 {
 
+// If true, we will connect to all new quorums and watch their communication
+static constexpr bool DEFAULT_WATCH_QUORUMS{false};
+
+
 class CQuorumSnapshot;
 
 // Use a separate cache instance instead of versionbitscache to avoid locking cs_main
@@ -41,55 +41,18 @@ enum class QvvecSyncMode {
     OnlyIfTypeMember = 1,
 };
 
-//QuorumMembers per quorumIndex at heights H-Cycle, H-2Cycles, H-3Cycles
-struct PreviousQuorumQuarters {
-    std::vector<std::vector<CDeterministicMNCPtr>> quarterHMinusC;
-    std::vector<std::vector<CDeterministicMNCPtr>> quarterHMinus2C;
-    std::vector<std::vector<CDeterministicMNCPtr>> quarterHMinus3C;
-    explicit PreviousQuorumQuarters(size_t s) :
-        quarterHMinusC(s), quarterHMinus2C(s), quarterHMinus3C(s) {}
-};
-
 class CLLMQUtils
 {
 public:
-    // includes members which failed DKG
-    static std::vector<CDeterministicMNCPtr> GetAllQuorumMembers(Consensus::LLMQType llmqType, const CBlockIndex* pQuorumBaseBlockIndex);
-
-    static void PreComputeQuorumMembers(const CBlockIndex* pQuorumBaseBlockIndex);
-    static std::vector<CDeterministicMNCPtr> ComputeQuorumMembers(Consensus::LLMQType llmqType, const CBlockIndex* pQuorumBaseBlockIndex);
-    static std::vector<std::vector<CDeterministicMNCPtr>> ComputeQuorumMembersByQuarterRotation(Consensus::LLMQType llmqType, const CBlockIndex* pCycleQuorumBaseBlockIndex);
-
-    static std::vector<std::vector<CDeterministicMNCPtr>> BuildNewQuorumQuarterMembers(const Consensus::LLMQParams& llmqParams, const CBlockIndex* pQuorumBaseBlockIndex, const PreviousQuorumQuarters& quarters);
-
-    static PreviousQuorumQuarters GetPreviousQuorumQuarterMembers(const Consensus::LLMQParams& llmqParams, const CBlockIndex* pBlockHMinusCIndex, const CBlockIndex* pBlockHMinus2CIndex, const CBlockIndex* pBlockHMinus3CIndex, int nHeight);
-    static std::vector<std::vector<CDeterministicMNCPtr>> GetQuorumQuarterMembersBySnapshot(const Consensus::LLMQParams& llmqParams, const CBlockIndex* pQuorumBaseBlockIndex, const llmq::CQuorumSnapshot& snapshot, int nHeights);
-    static std::pair<CDeterministicMNList, CDeterministicMNList> GetMNUsageBySnapshot(Consensus::LLMQType llmqType, const CBlockIndex* pQuorumBaseBlockIndex, const llmq::CQuorumSnapshot& snapshot, int nHeight);
-
-    static void BuildQuorumSnapshot(const Consensus::LLMQParams& llmqParams, const CDeterministicMNList& mnAtH, const CDeterministicMNList& mnUsedAtH, std::vector<CDeterministicMNCPtr>& sortedCombinedMns, CQuorumSnapshot& quorumSnapshot, int nHeight, std::vector<int>& skipList, const CBlockIndex* pQuorumBaseBlockIndex);
-
     static uint256 BuildCommitmentHash(Consensus::LLMQType llmqType, const uint256& blockHash, const std::vector<bool>& validMembers, const CBLSPublicKey& pubKey, const uint256& vvecHash);
     static uint256 BuildSignHash(Consensus::LLMQType llmqType, const uint256& quorumHash, const uint256& id, const uint256& msgHash);
 
     static bool IsAllMembersConnectedEnabled(Consensus::LLMQType llmqType);
     static bool IsQuorumPoseEnabled(Consensus::LLMQType llmqType);
     static uint256 DeterministicOutboundConnection(const uint256& proTxHash1, const uint256& proTxHash2);
-    static std::set<uint256> GetQuorumConnections(const Consensus::LLMQParams& llmqParams, const CBlockIndex* pQuorumBaseBlockIndex, const uint256& forMember, bool onlyOutbound);
-    static std::set<uint256> GetQuorumRelayMembers(const Consensus::LLMQParams& llmqParams, const CBlockIndex* pQuorumBaseBlockIndex, const uint256& forMember, bool onlyOutbound);
-    static std::set<size_t> CalcDeterministicWatchConnections(Consensus::LLMQType llmqType, const CBlockIndex* pQuorumBaseBlockIndex, size_t memberCount, size_t connectionCount);
-
-    static bool EnsureQuorumConnections(const Consensus::LLMQParams& llmqParams, const CBlockIndex* pQuorumBaseBlockIndex, CConnman& connman, const uint256& myProTxHash);
-    static void AddQuorumProbeConnections(const Consensus::LLMQParams& llmqParams, const CBlockIndex* pQuorumBaseBlockIndex, CConnman& connman, const uint256& myProTxHash);
 
-    static bool IsQuorumActive(Consensus::LLMQType llmqType, const uint256& quorumHash);
-    static bool IsQuorumTypeEnabled(Consensus::LLMQType llmqType, const CBlockIndex* pindex);
-    static bool IsQuorumTypeEnabledInternal(Consensus::LLMQType llmqType, const CBlockIndex* pindex, std::optional<bool> optDIP0024IsActive, std::optional<bool> optHaveDIP0024Quorums);
-
-    static std::vector<Consensus::LLMQType> GetEnabledQuorumTypes(const CBlockIndex* pindex);
-    static std::vector<std::reference_wrapper<const Consensus::LLMQParams>> GetEnabledQuorumParams(const CBlockIndex* pindex);
 
     static bool IsQuorumRotationEnabled(Consensus::LLMQType llmqType, const CBlockIndex* pindex);
-    static Consensus::LLMQType GetInstantSendLLMQType(const CBlockIndex* pindex);
     static Consensus::LLMQType GetInstantSendLLMQType(bool deterministic);
     static bool IsDIP0024Active(const CBlockIndex* pindex);
 
@@ -131,16 +94,6 @@ class CLLMQUtils
             }
         }
     }
-    static std::string ToHexStr(const std::vector<bool>& vBits)
-    {
-        std::vector<uint8_t> vBytes((vBits.size() + 7) / 8);
-        for (const auto i : irange::range(vBits.size())) {
-            vBytes[i / 8] |= vBits[i] << (i % 8);
-        }
-        return HexStr(vBytes);
-    }
-    template <typename CacheType>
-    static void InitQuorumsCache(CacheType& cache);
 };
 
 const Consensus::LLMQParams& GetLLMQParams(Consensus::LLMQType llmqType);
diff --git a/src/miner.cpp b/src/miner.cpp
index 1bcaa5734c8b..50ef2becbc76 100644
--- a/src/miner.cpp
+++ b/src/miner.cpp
@@ -27,7 +27,7 @@
 #include <evo/simplifiedmns.h>
 #include <llmq/blockprocessor.h>
 #include <llmq/chainlocks.h>
-#include <llmq/utils.h>
+#include <llmq/complex_utils.h>
 #include <masternode/payments.h>
 
 #include <algorithm>
@@ -138,7 +138,7 @@ std::unique_ptr<CBlockTemplate> BlockAssembler::CreateNewBlock(const CScript& sc
                        : pblock->GetBlockTime();
 
     if (fDIP0003Active_context) {
-        for (const Consensus::LLMQParams& params : llmq::CLLMQUtils::GetEnabledQuorumParams(pindexPrev)) {
+        for (const Consensus::LLMQParams& params : llmq::CLLMQComplexUtils::GetEnabledQuorumParams(pindexPrev)) {
             std::vector<CTransactionRef> vqcTx;
             if (llmq::quorumBlockProcessor->GetMineableCommitmentsTx(params,
                                                                      nHeight,
diff --git a/src/net_processing.cpp b/src/net_processing.cpp
index 03f2f5780f14..809d0bda9152 100644
--- a/src/net_processing.cpp
+++ b/src/net_processing.cpp
@@ -55,6 +55,7 @@
 #include <llmq/signing.h>
 #include <llmq/signing_shares.h>
 #include <llmq/snapshot.h>
+#include <llmq/utils.h>
 
 #include <statsd_client.h>
 
diff --git a/src/rpc/rpcquorums.cpp b/src/rpc/rpcquorums.cpp
index 2c09d734f895..18fddce1dde1 100644
--- a/src/rpc/rpcquorums.cpp
+++ b/src/rpc/rpcquorums.cpp
@@ -21,6 +21,8 @@
 #include <llmq/signing.h>
 #include <llmq/signing_shares.h>
 #include <llmq/snapshot.h>
+#include <llmq/utils.h>
+#include <llmq/complex_utils.h>
 
 namespace llmq {
 extern const std::string CLSIG_REQUESTID_PREFIX;
@@ -65,7 +67,7 @@ static UniValue quorum_list(const JSONRPCRequest& request)
 
     CBlockIndex* pindexTip = WITH_LOCK(cs_main, return ::ChainActive().Tip());
 
-    for (auto& type : llmq::CLLMQUtils::GetEnabledQuorumTypes(pindexTip)) {
+    for (auto& type : llmq::CLLMQComplexUtils::GetEnabledQuorumTypes(pindexTip)) {
         const auto& llmq_params = llmq::GetLLMQParams(type);
         UniValue v(UniValue::VARR);
 
@@ -194,7 +196,7 @@ static UniValue quorum_dkgstatus(const JSONRPCRequest& request)
 
     UniValue minableCommitments(UniValue::VARR);
     UniValue quorumArrConnections(UniValue::VARR);
-    for (const auto& type : llmq::CLLMQUtils::GetEnabledQuorumTypes(pindexTip)) {
+    for (const auto& type : llmq::CLLMQComplexUtils::GetEnabledQuorumTypes(pindexTip)) {
         const auto& llmq_params = llmq::GetLLMQParams(type);
 
         for (int quorumIndex = 0; quorumIndex < llmq_params.signingActiveQuorumCount; ++quorumIndex) {
@@ -210,9 +212,9 @@ static UniValue quorum_dkgstatus(const JSONRPCRequest& request)
                     obj.pushKV("quorumHash", pQuorumBaseBlockIndex->GetBlockHash().ToString());
                     obj.pushKV("pindexTip", pindexTip->nHeight);
 
-                    auto allConnections = llmq::CLLMQUtils::GetQuorumConnections(llmq_params, pQuorumBaseBlockIndex,
+                    auto allConnections = llmq::CLLMQComplexUtils::GetQuorumConnections(llmq_params, pQuorumBaseBlockIndex,
                                                                                  proTxHash, false);
-                    auto outboundConnections = llmq::CLLMQUtils::GetQuorumConnections(llmq_params,
+                    auto outboundConnections = llmq::CLLMQComplexUtils::GetQuorumConnections(llmq_params,
                                                                                       pQuorumBaseBlockIndex, proTxHash,
                                                                                       true);
                     std::map<uint256, CAddress> foundConnections;
@@ -297,7 +299,7 @@ static UniValue quorum_memberof(const JSONRPCRequest& request)
 
     UniValue result(UniValue::VARR);
 
-    for (const auto& type : llmq::CLLMQUtils::GetEnabledQuorumTypes(pindexTip)) {
+    for (const auto& type : llmq::CLLMQComplexUtils::GetEnabledQuorumTypes(pindexTip)) {
         const auto& llmq_params = llmq::GetLLMQParams(type);
         size_t count = llmq_params.signingActiveQuorumCount;
         if (scanQuorumsCount != -1) {
diff --git a/src/test/evo_utils_tests.cpp b/src/test/evo_utils_tests.cpp
index 6235100d8a62..72fe783ed888 100644
--- a/src/test/evo_utils_tests.cpp
+++ b/src/test/evo_utils_tests.cpp
@@ -4,7 +4,7 @@
 
 #include <test/util/setup_common.h>
 
-#include <llmq/utils.h>
+#include <llmq/complex_utils.h>
 #include <llmq/params.h>
 
 #include <chainparams.h>
@@ -20,21 +20,21 @@ void Test()
 {
     using namespace llmq;
     const auto& consensus_params = Params().GetConsensus();
-    BOOST_CHECK_EQUAL(CLLMQUtils::IsQuorumTypeEnabledInternal(consensus_params.llmqTypeInstantSend, nullptr, false, false), true);
-    BOOST_CHECK_EQUAL(CLLMQUtils::IsQuorumTypeEnabledInternal(consensus_params.llmqTypeInstantSend, nullptr, true, false), true);
-    BOOST_CHECK_EQUAL(CLLMQUtils::IsQuorumTypeEnabledInternal(consensus_params.llmqTypeInstantSend, nullptr, true, true), false);
-    BOOST_CHECK_EQUAL(CLLMQUtils::IsQuorumTypeEnabledInternal(consensus_params.llmqTypeDIP0024InstantSend, nullptr, false, false), false);
-    BOOST_CHECK_EQUAL(CLLMQUtils::IsQuorumTypeEnabledInternal(consensus_params.llmqTypeDIP0024InstantSend, nullptr, true, false), true);
-    BOOST_CHECK_EQUAL(CLLMQUtils::IsQuorumTypeEnabledInternal(consensus_params.llmqTypeDIP0024InstantSend, nullptr, true, true), true);
-    BOOST_CHECK_EQUAL(CLLMQUtils::IsQuorumTypeEnabledInternal(consensus_params.llmqTypeChainLocks, nullptr, false, false), true);
-    BOOST_CHECK_EQUAL(CLLMQUtils::IsQuorumTypeEnabledInternal(consensus_params.llmqTypeChainLocks, nullptr, false, false), true);
-    BOOST_CHECK_EQUAL(CLLMQUtils::IsQuorumTypeEnabledInternal(consensus_params.llmqTypeChainLocks, nullptr, true, false), true);
-    BOOST_CHECK_EQUAL(CLLMQUtils::IsQuorumTypeEnabledInternal(consensus_params.llmqTypePlatform, nullptr, true, false), Params().IsTestChain());
-    BOOST_CHECK_EQUAL(CLLMQUtils::IsQuorumTypeEnabledInternal(consensus_params.llmqTypePlatform, nullptr, true, true), Params().IsTestChain());
-    BOOST_CHECK_EQUAL(CLLMQUtils::IsQuorumTypeEnabledInternal(consensus_params.llmqTypePlatform, nullptr, true, true), Params().IsTestChain());
-    BOOST_CHECK_EQUAL(CLLMQUtils::IsQuorumTypeEnabledInternal(consensus_params.llmqTypeMnhf, nullptr, true, false), true);
-    BOOST_CHECK_EQUAL(CLLMQUtils::IsQuorumTypeEnabledInternal(consensus_params.llmqTypeMnhf, nullptr, true, true), true);
-    BOOST_CHECK_EQUAL(CLLMQUtils::IsQuorumTypeEnabledInternal(consensus_params.llmqTypeMnhf, nullptr, true, true), true);
+    BOOST_CHECK_EQUAL(CLLMQComplexUtils::IsQuorumTypeEnabledInternal(consensus_params.llmqTypeInstantSend, nullptr, false, false), true);
+    BOOST_CHECK_EQUAL(CLLMQComplexUtils::IsQuorumTypeEnabledInternal(consensus_params.llmqTypeInstantSend, nullptr, true, false), true);
+    BOOST_CHECK_EQUAL(CLLMQComplexUtils::IsQuorumTypeEnabledInternal(consensus_params.llmqTypeInstantSend, nullptr, true, true), false);
+    BOOST_CHECK_EQUAL(CLLMQComplexUtils::IsQuorumTypeEnabledInternal(consensus_params.llmqTypeDIP0024InstantSend, nullptr, false, false), false);
+    BOOST_CHECK_EQUAL(CLLMQComplexUtils::IsQuorumTypeEnabledInternal(consensus_params.llmqTypeDIP0024InstantSend, nullptr, true, false), true);
+    BOOST_CHECK_EQUAL(CLLMQComplexUtils::IsQuorumTypeEnabledInternal(consensus_params.llmqTypeDIP0024InstantSend, nullptr, true, true), true);
+    BOOST_CHECK_EQUAL(CLLMQComplexUtils::IsQuorumTypeEnabledInternal(consensus_params.llmqTypeChainLocks, nullptr, false, false), true);
+    BOOST_CHECK_EQUAL(CLLMQComplexUtils::IsQuorumTypeEnabledInternal(consensus_params.llmqTypeChainLocks, nullptr, false, false), true);
+    BOOST_CHECK_EQUAL(CLLMQComplexUtils::IsQuorumTypeEnabledInternal(consensus_params.llmqTypeChainLocks, nullptr, true, false), true);
+    BOOST_CHECK_EQUAL(CLLMQComplexUtils::IsQuorumTypeEnabledInternal(consensus_params.llmqTypePlatform, nullptr, true, false), Params().IsTestChain());
+    BOOST_CHECK_EQUAL(CLLMQComplexUtils::IsQuorumTypeEnabledInternal(consensus_params.llmqTypePlatform, nullptr, true, true), Params().IsTestChain());
+    BOOST_CHECK_EQUAL(CLLMQComplexUtils::IsQuorumTypeEnabledInternal(consensus_params.llmqTypePlatform, nullptr, true, true), Params().IsTestChain());
+    BOOST_CHECK_EQUAL(CLLMQComplexUtils::IsQuorumTypeEnabledInternal(consensus_params.llmqTypeMnhf, nullptr, true, false), true);
+    BOOST_CHECK_EQUAL(CLLMQComplexUtils::IsQuorumTypeEnabledInternal(consensus_params.llmqTypeMnhf, nullptr, true, true), true);
+    BOOST_CHECK_EQUAL(CLLMQComplexUtils::IsQuorumTypeEnabledInternal(consensus_params.llmqTypeMnhf, nullptr, true, true), true);
 }
 
 BOOST_FIXTURE_TEST_CASE(utils_IsQuorumTypeEnabled_tests_regtest, RegTestingSetup)
diff --git a/src/util/hexstr.cpp b/src/util/hexstr.cpp
new file mode 100644
index 000000000000..2059325e3f1b
--- /dev/null
+++ b/src/util/hexstr.cpp
@@ -0,0 +1,17 @@
+// Copyright (c) 2022 The Dash Core developers
+// Distributed under the MIT software license, see the accompanying
+// file COPYING or http://www.opensource.org/licenses/mit-license.php.
+
+#include <util/strencodings.h>
+
+#include <string>
+#include <vector>
+
+std::string BitsToHexStr(const std::vector<bool>& vBits)
+{
+    std::vector<uint8_t> vBytes((vBits.size() + 7) / 8);
+    for (size_t i = 0; i < vBits.size(); i++) {
+        vBytes[i / 8] |= vBits[i] << (i % 8);
+    }
+    return HexStr(vBytes);
+}
diff --git a/src/util/hexstr.h b/src/util/hexstr.h
new file mode 100644
index 000000000000..a88de8435e90
--- /dev/null
+++ b/src/util/hexstr.h
@@ -0,0 +1,13 @@
+// Copyright (c) 2022 The Dash Core developers
+// Distributed under the MIT software license, see the accompanying
+// file COPYING or http://www.opensource.org/licenses/mit-license.php.
+
+#ifndef BITCOIN_UTIL_GETUNIQUEPATH_H
+#define BITCOIN_UTIL_GETUNIQUEPATH_H
+
+#include <vector>
+#include <string>
+
+std::string BitsToHexStr(const std::vector<bool>& vBits);
+
+#endif // BITCOIN_UTIL_GETUNIQUEPATH_H
\ No newline at end of file
diff --git a/test/lint/lint-circular-dependencies.sh b/test/lint/lint-circular-dependencies.sh
index 82d73b32c95e..4ebced93c28f 100755
--- a/test/lint/lint-circular-dependencies.sh
+++ b/test/lint/lint-circular-dependencies.sh
@@ -33,7 +33,6 @@ EXPECTED_CIRCULAR_DEPENDENCIES=(
     "evo/cbtx -> evo/simplifiedmns -> evo/cbtx"
     "evo/deterministicmns -> evo/simplifiedmns -> evo/deterministicmns"
     "evo/deterministicmns -> llmq/commitment -> evo/deterministicmns"
-    "evo/deterministicmns -> llmq/utils -> evo/deterministicmns"
     "evo/mnauth -> net_processing -> evo/mnauth"
     "governance/classes -> governance/governance -> governance/classes"
     "governance/governance -> governance/object -> governance/governance"
@@ -41,7 +40,6 @@ EXPECTED_CIRCULAR_DEPENDENCIES=(
     "governance/governance -> net_processing -> governance/governance"
     "governance/object -> governance/validators -> governance/object"
     "hdchain -> wallet/walletdb -> hdchain"
-    "llmq/quorums -> llmq/utils -> llmq/quorums"
     "llmq/blockprocessor -> net_processing -> llmq/blockprocessor"
     "llmq/chainlocks -> llmq/instantsend -> llmq/chainlocks"
     "llmq/chainlocks -> net_processing -> llmq/chainlocks"
@@ -76,22 +74,39 @@ EXPECTED_CIRCULAR_DEPENDENCIES=(
 
     "coinjoin/client -> net_processing -> coinjoin/client"
     "llmq/quorums -> net_processing -> llmq/quorums"
-    "llmq/commitment -> llmq/utils -> llmq/commitment"
     "llmq/dkgsession -> llmq/dkgsessionmgr -> llmq/dkgsession"
     "evo/deterministicmns -> validationinterface -> txmempool -> evo/deterministicmns"
     "llmq/chainlocks -> validation -> llmq/chainlocks"
     "coinjoin/coinjoin -> llmq/chainlocks -> net -> coinjoin/coinjoin"
-    "evo/deterministicmns -> llmq/utils -> net -> evo/deterministicmns"
     "policy/fees -> txmempool -> validation -> policy/fees"
     "policy/policy -> policy/settings -> policy/policy"
     "evo/specialtxman -> validation -> evo/specialtxman"
-    "bloom -> llmq/commitment -> llmq/utils -> net -> bloom"
 
-    "evo/simplifiedmns -> llmq/blockprocessor -> net_processing -> llmq/snapshot -> evo/simplifiedmns"
-    "llmq/blockprocessor -> net_processing -> llmq/snapshot -> llmq/blockprocessor"
-    "llmq/dkgsession -> llmq/dkgsessionmgr -> llmq/quorums -> llmq/dkgsession"
-    "llmq/dkgsessionmgr -> llmq/quorums -> llmq/dkgsessionmgr"
-    "llmq/snapshot -> llmq/utils -> llmq/snapshot"
+    "llmq/commitment -> llmq/complex_utils -> llmq/commitment"
+    "llmq/complex_utils -> llmq/quorums -> llmq/complex_utils"
+    "evo/deterministicmns -> llmq/complex_utils -> llmq/quorums -> evo/deterministicmns"
+    "evo/deterministicmns -> llmq/complex_utils -> net -> evo/deterministicmns"
+    "evo/deterministicmns -> llmq/complex_utils -> evo/deterministicmns"
+    "llmq/blockprocessor -> llmq/complex_utils -> llmq/quorums -> llmq/blockprocessor"
+    "llmq/blockprocessor -> llmq/complex_utils -> llmq/snapshot -> llmq/blockprocessor"
+    "llmq/commitment -> llmq/complex_utils -> llmq/quorums -> llmq/commitment"
+    "llmq/commitment -> llmq/complex_utils -> llmq/snapshot -> llmq/commitment"
+    "llmq/complex_utils -> llmq/quorums -> llmq/dkgsession -> llmq/complex_utils"
+    "llmq/complex_utils -> llmq/quorums -> llmq/dkgsessionmgr -> llmq/complex_utils"
+    "bloom -> llmq/commitment -> llmq/complex_utils -> net -> bloom"
+    "evo/deterministicmns -> llmq/complex_utils -> llmq/quorums -> llmq/dkgsession -> evo/deterministicmns"
+    "evo/deterministicmns -> llmq/complex_utils -> llmq/quorums -> llmq/dkgsessionmgr -> evo/deterministicmns"
+    "evo/deterministicmns -> llmq/complex_utils -> llmq/quorums -> masternode/node -> evo/deterministicmns"
+    "evo/simplifiedmns -> llmq/blockprocessor -> llmq/complex_utils -> llmq/snapshot -> evo/simplifiedmns"
+    "llmq/commitment -> llmq/complex_utils -> llmq/quorums -> llmq/dkgsession -> llmq/commitment"
+    "llmq/commitment -> llmq/complex_utils -> llmq/quorums -> net_processing -> llmq/commitment"
+    "llmq/complex_utils -> llmq/quorums -> llmq/dkgsession -> llmq/debug -> llmq/complex_utils"
+    "llmq/complex_utils -> llmq/quorums -> llmq/dkgsessionmgr -> llmq/dkgsessionhandler -> llmq/complex_utils"
+    "evo/deterministicmns -> llmq/complex_utils -> llmq/quorums -> llmq/dkgsession -> llmq/debug -> evo/deterministicmns"
+    "evo/deterministicmns -> llmq/complex_utils -> llmq/quorums -> llmq/dkgsessionmgr -> llmq/dkgsessionhandler -> evo/deterministicmns"
+    "llmq/blockprocessor -> llmq/complex_utils -> llmq/quorums -> llmq/dkgsessionmgr -> llmq/dkgsessionhandler -> llmq/blockprocessor"
+    "llmq/commitment -> llmq/complex_utils -> llmq/quorums -> llmq/dkgsessionmgr -> llmq/dkgsessionhandler -> llmq/commitment"
+    "bloom -> llmq/commitment -> llmq/complex_utils -> llmq/quorums -> net_processing -> merkleblock -> bloom"
 )
 
 EXIT_CODE=0
@@ -109,7 +124,7 @@ for CIRC in $(cd src && ../contrib/devtools/circular-dependencies.py {*,*/*,*/*/
         fi
     done
     if [[ ${IS_EXPECTED_CIRC} == 0 ]]; then
-        echo "A new circular dependency in the form of \"${CIRC}\" appears to have been introduced."
+        echo "\"${CIRC}\""
         echo
         EXIT_CODE=1
     fi