diff --git a/src/Makefile.am b/src/Makefile.am
index 57d000012b00..49582bb2b658 100644
--- a/src/Makefile.am
+++ b/src/Makefile.am
@@ -222,7 +222,6 @@ BITCOIN_CORE_H = \
   dsnotificationinterface.h \
   evo/assetlocktx.h \
   evo/cbtx.h \
-  evo/chainhelper.h \
   evo/creditpool.h \
   evo/deterministicmns.h \
   evo/dmn_types.h \
@@ -548,7 +547,6 @@ libbitcoin_node_a_SOURCES = \
   dsnotificationinterface.cpp \
   evo/assetlocktx.cpp \
   evo/cbtx.cpp \
-  evo/chainhelper.cpp \
   evo/creditpool.cpp \
   evo/deterministicmns.cpp \
   evo/dmnstate.cpp \
@@ -1282,7 +1280,6 @@ libdashkernel_la_SOURCES = \
   deploymentstatus.cpp \
   evo/assetlocktx.cpp \
   evo/cbtx.cpp \
-  evo/chainhelper.cpp \
   evo/creditpool.cpp \
   evo/deterministicmns.cpp \
   evo/dmnstate.cpp \
@@ -1297,19 +1294,10 @@ libdashkernel_la_SOURCES = \
   evo/specialtx_filter.cpp \
   evo/specialtxman.cpp \
   flatfile.cpp \
-  governance/common.cpp \
-  governance/object.cpp \
-  governance/superblock.cpp \
-  governance/vote.cpp \
-  governance/votedb.cpp \
   gsl/assert.cpp \
   hash.cpp \
-  index/addressindex.cpp \
   index/addressindex_util.cpp \
   index/base.cpp \
-  index/blockfilterindex.cpp \
-  index/coinstatsindex.cpp \
-  index/spentindex.cpp \
   index/txindex.cpp \
   init/common.cpp \
   instantsend/db.cpp \
@@ -1326,9 +1314,6 @@ libdashkernel_la_SOURCES = \
   llmq/blockprocessor.cpp \
   llmq/commitment.cpp \
   llmq/context.cpp \
-  llmq/debug.cpp \
-  llmq/dkgsession.cpp \
-  llmq/dkgsessionhandler.cpp \
   llmq/dkgsessionmgr.cpp \
   llmq/options.cpp \
   llmq/quorums.cpp \
@@ -1340,7 +1325,6 @@ libdashkernel_la_SOURCES = \
   logging.cpp \
   masternode/meta.cpp \
   masternode/payments.cpp \
-  masternode/sync.cpp \
   merkleblock.cpp \
   messagesigner.cpp \
   netaddress.cpp \
diff --git a/src/active/context.cpp b/src/active/context.cpp
index a28ac91f5f71..83926f5e030a 100644
--- a/src/active/context.cpp
+++ b/src/active/context.cpp
@@ -27,7 +27,7 @@
 #include <validationinterface.h>
 
 ActiveContext::ActiveContext(CBLSWorker& bls_worker, ChainstateManager& chainman, CConnman& connman,
-                             CDeterministicMNManager& dmnman, CGovernanceManager& govman,
+                             CDeterministicMNManager& dmnman, CGovernanceManager& govman, CMNHFManager& mnhfman,
                              governance::SuperblockManager& superblocks, CSporkManager& sporkman,
                              const chainlock::Chainlocks& chainlocks, CTxMemPool& mempool,
                              chainlock::ChainlockHandler& clhandler, llmq::CInstantSendManager& isman,
@@ -43,7 +43,7 @@ ActiveContext::ActiveContext(CBLSWorker& bls_worker, ChainstateManager& chainman
     qdkgsman{std::make_unique<llmq::CDKGSessionManager>(dmnman, qsnapman, chainman, sporkman, db_params)},
     shareman{std::make_unique<llmq::CSigSharesManager>(connman, chainman, sigman, *nodeman, qman, sporkman)},
     gov_signer{std::make_unique<GovernanceSigner>(dmnman, govman, superblocks, *nodeman, chainman, mn_sync)},
-    ehf_sighandler{std::make_unique<llmq::CEHFSignalsHandler>(chainman, sigman, *shareman, qman)},
+    ehf_sighandler{std::make_unique<llmq::CEHFSignalsHandler>(chainman, mnhfman, sigman, *shareman, qman)},
     cl_signer{std::make_unique<chainlock::ChainLockSigner>(chainman, chainlocks, clhandler, isman,
                                                            qman, sigman, *shareman, mn_sync)},
     is_signer{std::make_unique<instantsend::InstantSendSigner>(chainman, chainlocks, isman, sigman,
diff --git a/src/active/context.h b/src/active/context.h
index d7d45d8e15e2..dcaa1781f144 100644
--- a/src/active/context.h
+++ b/src/active/context.h
@@ -59,7 +59,7 @@ struct ActiveContext final : public llmq::QuorumRole, public CValidationInterfac
     ActiveContext(const ActiveContext&) = delete;
     ActiveContext& operator=(const ActiveContext&) = delete;
     explicit ActiveContext(CBLSWorker& bls_worker, ChainstateManager& chainman, CConnman& connman,
-                           CDeterministicMNManager& dmnman, CGovernanceManager& govman,
+                           CDeterministicMNManager& dmnman, CGovernanceManager& govman, CMNHFManager& mnhfman,
                            governance::SuperblockManager& superblocks, CSporkManager& sporkman,
                            const chainlock::Chainlocks& chainlocks, CTxMemPool& mempool,
                            chainlock::ChainlockHandler& clhandler, llmq::CInstantSendManager& isman,
diff --git a/src/bitcoin-chainstate.cpp b/src/bitcoin-chainstate.cpp
index 204c4701f08d..531872340c74 100644
--- a/src/bitcoin-chainstate.cpp
+++ b/src/bitcoin-chainstate.cpp
@@ -19,14 +19,13 @@
 #include <chainparams.h>
 #include <consensus/validation.h>
 #include <core_io.h>
-#include <evo/chainhelper.h>
 #include <evo/deterministicmns.h>
 #include <evo/evodb.h>
+#include <evo/specialtxman.h>
 #include <init/common.h>
-#include <instantsend/instantsend.h>
 #include <llmq/context.h>
+#include <llmq/options.h>
 #include <masternode/meta.h>
-#include <masternode/sync.h>
 #include <node/blockstorage.h>
 #include <node/caches.h>
 #include <node/chainstate.h>
@@ -98,27 +97,27 @@ int main(int argc, char* argv[])
     CMasternodeMetaMan metaman;
     CEvoDB evodb{util::DbWrapperParams{.path = gArgs.GetDataDirNet(), .memory = false, .wipe = false}};
     CDeterministicMNManager dmnman{evodb, metaman};
-    CMasternodeSync mn_sync{std::make_unique<NullNodeSyncNotifier>()};
     CSporkManager sporkman;
     chainlock::Chainlocks chainlocks(sporkman);
-    // TODO: remove isman from bitcoin-chainstate and make it nullable for node::ChainstateLoadOptions same as mempool
-    llmq::CInstantSendManager isman{sporkman, util::DbWrapperParams{.path = gArgs.GetDataDirNet(), .memory = false, .wipe = false}};
 
-    std::unique_ptr<LLMQContext> llmq_ctx;
-    std::unique_ptr<CChainstateHelper> chain_helper;
+    auto llmq_ctx = WITH_LOCK(::cs_main, return std::make_unique<LLMQContext>(dmnman, evodb, chainman,
+                                                                              util::DbWrapperParams{.path = gArgs.GetDataDirNet(), .memory = false, .wipe = false},
+                                                                              llmq::DEFAULT_BLSCHECK_THREADS, llmq::DEFAULT_WORKER_COUNT, llmq::DEFAULT_MAX_RECOVERED_SIGS_AGE));
+    auto special_tx = std::make_unique<CSpecialTxProcessor>(evodb, dmnman,
+                                                            *llmq_ctx->quorum_block_processor, *llmq_ctx->qsnapman,
+                                                            chainman, chainman.m_blockman, chainman.GetConsensus(),
+                                                            chainlocks, *llmq_ctx->qman);
 
     node::CacheSizes cache_sizes;
     cache_sizes.block_tree_db = 2 << 20;
     cache_sizes.coins_db = 2 << 22;
     cache_sizes.coins = (450 << 20) - (2 << 20) - (2 << 22);
     node::ChainstateLoadOptions options;
-    options.isman = &isman;
     options.chainlocks = &chainlocks;
-    options.mn_sync = &mn_sync;
     options.data_dir = gArgs.GetDataDirNet();
     options.check_interrupt = [] { return false; };
     options.coins_error_cb = [] {};
-    auto [status, error] = node::LoadChainstate(chainman, cache_sizes, options, evodb, dmnman, llmq_ctx, chain_helper);
+    auto [status, error] = node::LoadChainstate(chainman, cache_sizes, options, evodb, dmnman, *special_tx);
     if (status != node::ChainstateLoadStatus::SUCCESS) {
         std::cerr << "Failed to load Chain state from your datadir." << std::endl;
         goto epilogue;
@@ -280,6 +279,6 @@ int main(int argc, char* argv[])
     }
     GetMainSignals().UnregisterBackgroundSignalScheduler();
     // Tear down Dash kernel objects before kernel::~Context().
-    chain_helper.reset();
+    special_tx.reset();
     llmq_ctx.reset();
 }
diff --git a/src/evo/chainhelper.cpp b/src/evo/chainhelper.cpp
deleted file mode 100644
index 8e92000851e1..000000000000
--- a/src/evo/chainhelper.cpp
+++ /dev/null
@@ -1,104 +0,0 @@
-// Copyright (c) 2024-2025 The Dash Core developers
-// Distributed under the MIT/X11 software license, see the accompanying
-// file COPYING or http://www.opensource.org/licenses/mit-license.php.
-
-#include <evo/chainhelper.h>
-
-#include <chainlock/chainlock.h>
-#include <chainparams.h>
-#include <evo/creditpool.h>
-#include <evo/deterministicmns.h>
-#include <evo/mnhftx.h>
-#include <evo/specialtxman.h>
-#include <governance/superblock.h>
-#include <hash.h>
-#include <instantsend/instantsend.h>
-#include <instantsend/lock.h>
-#include <logging.h>
-#include <masternode/payments.h>
-#include <masternode/sync.h>
-#include <util/check.h>
-
-CChainstateHelper::CChainstateHelper(CEvoDB& evodb, CDeterministicMNManager& dmnman, const CMasternodeSync& mn_sync,
-                                     llmq::CInstantSendManager& isman, llmq::CQuorumBlockProcessor& qblockman,
-                                     llmq::CQuorumSnapshotManager& qsnapman, const ChainstateManager& chainman,
-                                     const node::BlockManager& blockman, const Consensus::Params& consensus_params,
-                                     const chainlock::Chainlocks& chainlocks, const llmq::CQuorumManager& qman) :
-    isman{isman},
-    mn_sync{mn_sync},
-    m_dmnman{dmnman},
-    credit_pool_manager{std::make_unique<CCreditPoolManager>(evodb, chainman)},
-    m_chainlocks{chainlocks},
-    ehf_manager{std::make_unique<CMNHFManager>(evodb, consensus_params)},
-    superblocks{std::make_unique<governance::SuperblockManager>()},
-    mn_payments{std::make_unique<CMNPaymentsProcessor>(dmnman, *superblocks, consensus_params)},
-    special_tx{std::make_unique<CSpecialTxProcessor>(*credit_pool_manager, dmnman, *ehf_manager, qblockman, qsnapman,
-                                                     chainman, blockman, consensus_params, chainlocks, qman)}
-{}
-
-CChainstateHelper::~CChainstateHelper() = default;
-
-bool CChainstateHelper::IsSuperblockValidationRequired(const CBlockIndex* const pindex)
-{
-    if (m_chainlocks.GetBestChainLockHeight() >= pindex->nHeight) {
-        LogPrint(BCLog::MNPAYMENTS, "%s -- validation of chainlocked block=%s is skipped\n", __func__, pindex->GetBlockHash().ToString());
-        return false;
-    }
-    if (!mn_sync.IsSynced()) {
-        LogPrint(BCLog::MNPAYMENTS, "%s -- WARNING! Node is not fully synced, checked superblock for block=%s max bounds only\n", __func__, pindex->GetBlockHash().ToString());
-        return false;
-    }
-    return true;
-}
-
-/** Passthrough functions to chainlock::Chainlocks */
-bool CChainstateHelper::HasConflictingChainLock(int nHeight, const uint256& blockHash) const
-{
-    return m_chainlocks.HasConflictingChainLock(nHeight, blockHash);
-}
-
-bool CChainstateHelper::HasChainLock(int nHeight, const uint256& blockHash) const
-{
-    return m_chainlocks.HasChainLock(nHeight, blockHash);
-}
-
-int32_t CChainstateHelper::GetBestChainLockHeight() const { return m_chainlocks.GetBestChainLockHeight(); }
-
-uint256 CChainstateHelper::GetDeterministicMNListHash(const CBlockIndex* pindex) const
-{
-    return SerializeHash(m_dmnman.GetListForBlock(Assert(pindex)));
-}
-
-/** Passthrough functions to CCreditPoolManager */
-CCreditPool CChainstateHelper::GetCreditPool(const CBlockIndex* const pindex)
-{
-    return credit_pool_manager->GetCreditPool(pindex);
-}
-
-/** Passthrough functions to CInstantSendManager */
-std::optional<std::pair</*islock_hash=*/uint256, /*txid=*/uint256>> CChainstateHelper::ConflictingISLockIfAny(
-    const CTransaction& tx) const
-{
-    const auto islock = isman.GetConflictingLock(tx);
-    if (!islock) return std::nullopt;
-    return std::make_pair(::SerializeHash(*islock), islock->txid);
-}
-
-bool CChainstateHelper::IsInstantSendEnabled() const { return isman.IsInstantSendEnabled(); }
-
-bool CChainstateHelper::IsInstantSendLocked(const uint256& hash) const { return isman.IsLocked(hash); }
-
-bool CChainstateHelper::IsInstantSendWaitingForTx(const uint256& hash) const { return isman.IsWaitingForTx(hash); }
-
-bool CChainstateHelper::RemoveConflictingISLockByTx(const CTransaction& tx)
-{
-    const auto islock = isman.GetConflictingLock(tx);
-    if (!islock) return false;
-    isman.RemoveConflictingLock(::SerializeHash(*islock), *islock);
-    return true;
-}
-
-std::map<uint8_t, int> CChainstateHelper::GetSignalsStage(const CBlockIndex* const pindexPrev)
-{
-    return ehf_manager->GetSignalsStage(pindexPrev);
-}
diff --git a/src/evo/chainhelper.h b/src/evo/chainhelper.h
deleted file mode 100644
index a501dd82ceaf..000000000000
--- a/src/evo/chainhelper.h
+++ /dev/null
@@ -1,92 +0,0 @@
-// Copyright (c) 2024-2025 The Dash Core developers
-// Distributed under the MIT/X11 software license, see the accompanying
-// file COPYING or http://www.opensource.org/licenses/mit-license.php.
-
-#ifndef BITCOIN_EVO_CHAINHELPER_H
-#define BITCOIN_EVO_CHAINHELPER_H
-
-#include <cstdint>
-#include <map>
-#include <memory>
-#include <optional>
-
-class CBlockIndex;
-class CCreditPoolManager;
-class CDeterministicMNManager;
-class CEvoDB;
-class ChainstateManager;
-class CMasternodeSync;
-class CMNHFManager;
-class CMNPaymentsProcessor;
-class CSpecialTxProcessor;
-class CTransaction;
-class uint256;
-struct CCreditPool;
-namespace chainlock {
-class Chainlocks;
-} // namespace chainlock
-namespace governance {
-class SuperblockManager;
-} // namespace governance
-namespace Consensus {
-struct Params;
-} // namespace Consensus
-namespace llmq {
-class CInstantSendManager;
-class CQuorumBlockProcessor;
-class CQuorumManager;
-class CQuorumSnapshotManager;
-} // namespace llmq
-namespace node {
-class BlockManager;
-} // namespace node
-class CChainstateHelper
-{
-private:
-    llmq::CInstantSendManager& isman;
-    const CMasternodeSync& mn_sync;
-    CDeterministicMNManager& m_dmnman;
-
-public:
-    const std::unique_ptr<CCreditPoolManager> credit_pool_manager;
-    const chainlock::Chainlocks& m_chainlocks;
-    const std::unique_ptr<CMNHFManager> ehf_manager;
-    const std::unique_ptr<governance::SuperblockManager> superblocks;
-    const std::unique_ptr<CMNPaymentsProcessor> mn_payments;
-    const std::unique_ptr<CSpecialTxProcessor> special_tx;
-
-public:
-    CChainstateHelper() = delete;
-    CChainstateHelper(const CChainstateHelper&) = delete;
-    CChainstateHelper& operator=(const CChainstateHelper&) = delete;
-    explicit CChainstateHelper(CEvoDB& evodb, CDeterministicMNManager& dmnman, const CMasternodeSync& mn_sync,
-                               llmq::CInstantSendManager& isman, llmq::CQuorumBlockProcessor& qblockman,
-                               llmq::CQuorumSnapshotManager& qsnapman, const ChainstateManager& chainman,
-                               const node::BlockManager& blockman, const Consensus::Params& consensus_params,
-                               const chainlock::Chainlocks& chainlocks, const llmq::CQuorumManager& qman);
-    ~CChainstateHelper();
-
-    bool IsSuperblockValidationRequired(const CBlockIndex* const pindex);
-
-    /** Passthrough functions to chainlock::Chainlocks */
-    bool HasConflictingChainLock(int nHeight, const uint256& blockHash) const;
-    bool HasChainLock(int nHeight, const uint256& blockHash) const;
-    int32_t GetBestChainLockHeight() const;
-
-    /** Return a canonical hash of the deterministic MN list derived at a block. */
-    uint256 GetDeterministicMNListHash(const CBlockIndex* pindex) const;
-
-    /** Passthrough functions to CCreditPoolManager */
-    CCreditPool GetCreditPool(const CBlockIndex* const pindex);
-
-    /** Passthrough functions to CInstantSendManager */
-    std::optional<std::pair</*islock_hash=*/uint256, /*txid=*/uint256>> ConflictingISLockIfAny(const CTransaction& tx) const;
-    bool IsInstantSendEnabled() const;
-    bool IsInstantSendLocked(const uint256& hash) const;
-    bool IsInstantSendWaitingForTx(const uint256& hash) const;
-    bool RemoveConflictingISLockByTx(const CTransaction& tx);
-
-    std::map<uint8_t, int> GetSignalsStage(const CBlockIndex* const pindexPrev);
-};
-
-#endif // BITCOIN_EVO_CHAINHELPER_H
diff --git a/src/evo/providertx_service.cpp b/src/evo/providertx_service.cpp
index aa9426567183..5f776847cddb 100644
--- a/src/evo/providertx_service.cpp
+++ b/src/evo/providertx_service.cpp
@@ -7,7 +7,6 @@
 #include <consensus/tx_verify.h>
 #include <consensus/validation.h>
 #include <deploymentstatus.h>
-#include <evo/chainhelper.h>
 #include <evo/deterministicmns.h>
 #include <evo/netinfo.h>
 #include <evo/providertx.h>
@@ -360,7 +359,7 @@ std::optional<ProviderTxError> Preflight(node::NodeContext& node, const CTransac
 {
     AssertLockNotHeld(::cs_main);
     auto& chainman{*Assert(node.chainman)};
-    auto& chain_helper{*Assert(node.chain_helper)};
+    auto& special_tx{*Assert(node.special_tx)};
     LOCK(::cs_main);
 
     const CBlockIndex* tip{chainman.ActiveChain().Tip()};
@@ -379,7 +378,7 @@ std::optional<ProviderTxError> Preflight(node::NodeContext& node, const CTransac
     }
 
     TxValidationState state;
-    if (!chain_helper.special_tx->CheckSpecialTx(tx, tip, GetSpecialTxRules(tip, chainman),
+    if (!special_tx.CheckSpecialTx(tx, tip, GetSpecialTxRules(tip, chainman),
                                                  chainman.ActiveChainstate().CoinsTip(), true, state)) {
         return Error(ProviderTxErrorCode::CONSENSUS_REJECTED, state.ToString(), state.GetRejectReason());
     }
diff --git a/src/evo/specialtxman.cpp b/src/evo/specialtxman.cpp
index 28f59ec6ced5..aef331c99d8d 100644
--- a/src/evo/specialtxman.cpp
+++ b/src/evo/specialtxman.cpp
@@ -30,6 +30,26 @@
 #include <primitives/block.h>
 #include <util/system.h>
 
+CSpecialTxProcessor::CSpecialTxProcessor(CEvoDB& evodb, CDeterministicMNManager& dmnman,
+                                         llmq::CQuorumBlockProcessor& qblockman, llmq::CQuorumSnapshotManager& qsnapman,
+                                         const ChainstateManager& chainman, const node::BlockManager& blockman,
+                                         const Consensus::Params& consensus_params,
+                                         const chainlock::Chainlocks& chainlocks, const llmq::CQuorumManager& qman) :
+    m_cpoolman{std::make_unique<CCreditPoolManager>(evodb, chainman)},
+    m_mnhfman{std::make_unique<CMNHFManager>(evodb, consensus_params)},
+    m_dmnman{dmnman},
+    m_qblockman{qblockman},
+    m_qsnapman{qsnapman},
+    m_chainman(chainman),
+    m_blockman{blockman},
+    m_consensus_params{consensus_params},
+    m_chainlocks{chainlocks},
+    m_qman{qman}
+{
+}
+
+CSpecialTxProcessor::~CSpecialTxProcessor() = default;
+
 static bool AddNetInfoEntries(const std::shared_ptr<NetInfoInterface>& net_info, NetInfoPurpose purpose,
                               const NetInfoList& entries, BlockValidationState& state)
 {
@@ -794,6 +814,11 @@ bool CSpecialTxProcessor::RebuildListFromBlock(const CBlock& block, gsl::not_nul
     return true;
 }
 
+uint256 CSpecialTxProcessor::GetDeterministicMNListHash(gsl::not_null<const CBlockIndex*> pindex) const
+{
+    return SerializeHash(m_dmnman.GetListForBlock(pindex));
+}
+
 bool CSpecialTxProcessor::ProcessSpecialTxsInBlock(Chainstate& chainstate, const CChain& chain, const CBlock& block,
                                                    const CBlockIndex* pindex, SpecialTxRules rules,
                                                    const CCoinsViewCache& view, CAmount blockSubsidy, bool fJustCheck,
@@ -845,7 +870,7 @@ bool CSpecialTxProcessor::ProcessSpecialTxsInBlock(Chainstate& chainstate, const
 
         CRangesSet indexes;
         if (DeploymentActiveAt(*pindex, m_consensus_params, Consensus::DEPLOYMENT_V20)) {
-            CCreditPool creditPool{m_cpoolman.GetCreditPool(pindex->pprev)};
+            CCreditPool creditPool{m_cpoolman->GetCreditPool(pindex->pprev)};
             LogPrint(BCLog::CREDITPOOL, "CSpecialTxProcessor::%s -- CCreditPool is %s\n", __func__, creditPool.ToString());
             indexes = std::move(creditPool.indexes);
         }
@@ -904,6 +929,9 @@ bool CSpecialTxProcessor::ProcessSpecialTxsInBlock(Chainstate& chainstate, const
 
         CDeterministicMNList mn_list;
         if (DeploymentActiveAt(*pindex, m_consensus_params, Consensus::DEPLOYMENT_DIP0003)) {
+            // ConnectBlock validates masternode payments against the list at the
+            // previous block, also under fJustCheck where ProcessBlock is skipped.
+            updatesRet.old_list = m_dmnman.GetListForBlock(pindex->pprev);
             if (!BuildNewListFromBlock(block, pindex->pprev, rules.v24, view, true, state, mn_list)) {
                 // pass the state returned by the function above
                 return false;
@@ -970,14 +998,14 @@ bool CSpecialTxProcessor::ProcessSpecialTxsInBlock(Chainstate& chainstate, const
 
         int64_t nTime7 = GetTimeMicros();
 
-        if (!m_mnhfman.ProcessBlock(block, pindex, fJustCheck, state)) {
+        if (!m_mnhfman->ProcessBlock(block, pindex, fJustCheck, state)) {
             // pass the state returned by the function above
             return false;
         }
 
         int64_t nTime8 = GetTimeMicros();
         nTimeMnehf += nTime8 - nTime7;
-        LogPrint(BCLog::BENCHMARK, "      - m_mnhfman.ProcessBlock: %.2fms [%.2fs]\n", 0.001 * (nTime8 - nTime7),
+        LogPrint(BCLog::BENCHMARK, "      - m_mnhfman->ProcessBlock: %.2fms [%.2fs]\n", 0.001 * (nTime8 - nTime7),
                  nTimeMnehf * 0.000001);
 
         if (DeploymentActiveAfter(pindex, m_consensus_params, Consensus::DEPLOYMENT_V19) && bls::bls_legacy_scheme.load()) {
@@ -1012,7 +1040,7 @@ bool CSpecialTxProcessor::UndoSpecialTxsInBlock(const Chainstate& chainstate, co
             LogPrintf("CSpecialTxProcessor::%s -- bls_legacy_scheme=%d\n", __func__, bls::bls_legacy_scheme.load());
         }
 
-        if (!m_mnhfman.UndoBlock(block, pindex)) {
+        if (!m_mnhfman->UndoBlock(block, pindex)) {
             return false;
         }
 
@@ -1042,7 +1070,7 @@ bool CSpecialTxProcessor::CheckCreditPoolDiffForBlock(const CBlock& block, const
     if (!DeploymentActiveAt(*pindex, m_consensus_params, Consensus::DEPLOYMENT_V20)) return true;
 
     try {
-        const auto creditPoolDiff = GetCreditPoolDiffForBlock(m_cpoolman, block,
+        const auto creditPoolDiff = GetCreditPoolDiffForBlock(*m_cpoolman, block,
                                                               pindex->pprev, m_consensus_params, blockSubsidy, state);
         if (!creditPoolDiff.has_value()) return false;
 
diff --git a/src/evo/specialtxman.h b/src/evo/specialtxman.h
index c90858d22062..1481ad01683a 100644
--- a/src/evo/specialtxman.h
+++ b/src/evo/specialtxman.h
@@ -11,6 +11,7 @@
 #include <sync.h>
 #include <threadsafety.h>
 
+#include <memory>
 #include <optional>
 
 class BlockValidationState;
@@ -22,6 +23,7 @@ class CCoinsViewCache;
 class CCreditPoolManager;
 class CDeterministicMNList;
 class CDeterministicMNManager;
+class CEvoDB;
 class CProDisTx;
 class CRangesSet;
 class CTransaction;
@@ -29,6 +31,7 @@ class ChainstateManager;
 class Chainstate;
 class CMNHFManager;
 class TxValidationState;
+class uint256;
 struct MNListUpdates;
 
 namespace chainlock {
@@ -54,10 +57,14 @@ struct SpecialTxRules {
 
 class CSpecialTxProcessor
 {
+public:
+    //! Credit-pool and EHF-signal state is carried by special transactions,
+    //! so the processor owns their managers; other consumers reach them here.
+    const std::unique_ptr<CCreditPoolManager> m_cpoolman;
+    const std::unique_ptr<CMNHFManager> m_mnhfman;
+
 private:
-    CCreditPoolManager& m_cpoolman;
     CDeterministicMNManager& m_dmnman;
-    CMNHFManager& m_mnhfman;
     llmq::CQuorumBlockProcessor& m_qblockman;
     llmq::CQuorumSnapshotManager& m_qsnapman;
     const ChainstateManager& m_chainman;
@@ -67,23 +74,12 @@ class CSpecialTxProcessor
     const llmq::CQuorumManager& m_qman;
 
 public:
-    explicit CSpecialTxProcessor(CCreditPoolManager& cpoolman, CDeterministicMNManager& dmnman, CMNHFManager& mnhfman,
+    explicit CSpecialTxProcessor(CEvoDB& evodb, CDeterministicMNManager& dmnman,
                                  llmq::CQuorumBlockProcessor& qblockman, llmq::CQuorumSnapshotManager& qsnapman,
                                  const ChainstateManager& chainman, const node::BlockManager& blockman,
                                  const Consensus::Params& consensus_params, const chainlock::Chainlocks& chainlocks,
-                                 const llmq::CQuorumManager& qman) :
-        m_cpoolman(cpoolman),
-        m_dmnman{dmnman},
-        m_mnhfman{mnhfman},
-        m_qblockman{qblockman},
-        m_qsnapman{qsnapman},
-        m_chainman(chainman),
-        m_blockman{blockman},
-        m_consensus_params{consensus_params},
-        m_chainlocks{chainlocks},
-        m_qman{qman}
-    {
-    }
+                                 const llmq::CQuorumManager& qman);
+    ~CSpecialTxProcessor();
 
     bool CheckSpecialTx(const CTransaction& tx, const CBlockIndex* pindexPrev, SpecialTxRules rules,
                         const CCoinsViewCache& view, bool check_sigs, TxValidationState& state)
@@ -108,6 +104,9 @@ class CSpecialTxProcessor
                               const CDeterministicMNList& prevList, const CCoinsViewCache& view, bool debugLogs,
                               BlockValidationState& state, CDeterministicMNList& mnListRet);
 
+    /** Return a canonical hash of the deterministic MN list derived at a block. */
+    uint256 GetDeterministicMNListHash(gsl::not_null<const CBlockIndex*> pindex) const;
+
 private:
     bool CheckSpecialTxInner(const CChain* chain, const CTransaction& tx, const CBlockIndex* pindexPrev,
                              SpecialTxRules rules, const CCoinsViewCache& view, const std::optional<CRangesSet>& indexes,
diff --git a/src/governance/governance.cpp b/src/governance/governance.cpp
index 6e34c5c56e95..78adb6e72af3 100644
--- a/src/governance/governance.cpp
+++ b/src/governance/governance.cpp
@@ -88,7 +88,7 @@ CGovernanceManager::CGovernanceManager(CMasternodeMetaMan& mn_metaman, const Cha
 CGovernanceManager::~CGovernanceManager()
 {
     // Reset the paired SuperblockManager so its loaded-flag and trigger map don't
-    // outlive us. chain_helper (its owner) must outlive govman -- see PrepareShutdown
+    // outlive us. node.sbman (its owner) must outlive govman -- see PrepareShutdown
     // in init.cpp and the test teardown ordering.
     m_superblocks.Clear();
     if (!is_loaded) return;
diff --git a/src/governance/signing.cpp b/src/governance/signing.cpp
index 1eea9b60dac6..da2b5752085e 100644
--- a/src/governance/signing.cpp
+++ b/src/governance/signing.cpp
@@ -57,7 +57,7 @@ std::optional<const CSuperblock> GovernanceSigner::CreateSuperblockCandidate(int
     CSuperblock::GetNearestSuperblocksHeights(nHeight, nLastSuperblock, nNextSuperblock);
     auto SBEpochTime = static_cast<int64_t>(GetTime<std::chrono::seconds>().count() +
                                             (nNextSuperblock - nHeight) * 2.62 * 60);
-    auto governanceBudget = WITH_LOCK(::cs_main, return CSuperblock::GetPaymentsLimit(m_chainman.ActiveChain(), nNextSuperblock));
+    auto governanceBudget = CSuperblock::GetPaymentsLimit(nNextSuperblock);
 
     CAmount budgetAllocated{};
     for (const auto& proposal : approvedProposals) {
diff --git a/src/governance/superblock.cpp b/src/governance/superblock.cpp
index 54213f62579b..e4bfeb171e12 100644
--- a/src/governance/superblock.cpp
+++ b/src/governance/superblock.cpp
@@ -11,6 +11,7 @@
 #include <governance/vote.h>
 #include <key_io.h>
 #include <logging.h>
+#include <masternode/payments.h>
 #include <primitives/transaction.h>
 #include <util/std23.h>
 #include <util/strencodings.h>
@@ -118,9 +119,7 @@ CSuperblock::CSuperblock(int nBlockHeight, std::vector<CGovernancePayment> vecPa
 
 bool CSuperblock::IsValidBlockHeight(int nBlockHeight)
 {
-    // SUPERBLOCKS CAN HAPPEN ONLY after hardfork and only ONCE PER CYCLE
-    return nBlockHeight >= Params().GetConsensus().nSuperblockStartBlock &&
-           ((nBlockHeight % Params().GetConsensus().nSuperblockCycle) == 0);
+    return IsSuperblockHeight(nBlockHeight, Params().GetConsensus());
 }
 
 void CSuperblock::GetNearestSuperblocksHeights(int nBlockHeight, int& nLastSuperblockRet, int& nNextSuperblockRet)
@@ -142,24 +141,9 @@ void CSuperblock::GetNearestSuperblocksHeights(int nBlockHeight, int& nLastSuper
     }
 }
 
-CAmount CSuperblock::GetPaymentsLimit(const CChain& active_chain, int nBlockHeight)
+CAmount CSuperblock::GetPaymentsLimit(int nBlockHeight)
 {
-    const Consensus::Params& consensusParams = Params().GetConsensus();
-
-    if (!IsValidBlockHeight(nBlockHeight)) {
-        return 0;
-    }
-
-    const bool fV20Active{nBlockHeight >= consensusParams.V20Height};
-
-    // min subsidy for high diff networks and vice versa
-    int nBits = consensusParams.fPowAllowMinDifficultyBlocks ? UintToArith256(consensusParams.powLimit).GetCompact() : 1;
-    // some part of all blocks issued during the cycle goes to superblock, see GetBlockSubsidy
-    CAmount nSuperblockPartOfSubsidy = GetSuperblockSubsidyInner(nBits, nBlockHeight - 1, consensusParams, fV20Active);
-    CAmount nPaymentsLimit = nSuperblockPartOfSubsidy * consensusParams.nSuperblockCycle;
-    LogPrint(BCLog::GOBJECT, "CSuperblock::GetPaymentsLimit -- Valid superblock height %d, payments max %lld\n", nBlockHeight, nPaymentsLimit);
-
-    return nPaymentsLimit;
+    return GetSuperblockPaymentsLimit(nBlockHeight, Params().GetConsensus());
 }
 
 void CSuperblock::ParsePaymentSchedule(const std::string& strPaymentAddresses, const std::string& strPaymentAmounts, const std::string& strProposalHashes)
@@ -234,108 +218,6 @@ bool CSuperblock::GetPayment(int nPaymentIndex, CGovernancePayment& paymentRet)
     return true;
 }
 
-CAmount CSuperblock::GetPaymentsTotalAmount()
-{
-    return std23::ranges::fold_left(vecPayments, CAmount{0}, [](CAmount s, const auto& p) { return s + p.nAmount; });
-}
-
-/**
-*   Is Transaction Valid
-*
-*   - Does this transaction match the superblock?
-*/
-
-bool CSuperblock::IsValid(const CChain& active_chain, const CTransaction& txNew, int block_height, CAmount blockReward, bool is_v24)
-{
-    // TODO : LOCK(cs);
-    // No reason for a lock here now since this method only accesses data
-    // internal to *this and since CSuperblock's are accessed only through
-    // shared pointers there's no way our object can get deleted while this
-    // code is running.
-    if (!IsValidBlockHeight(block_height)) {
-        LogPrintf("CSuperblock::IsValid -- ERROR: Block invalid, incorrect block height\n");
-        return false;
-    }
-
-    // CONFIGURE SUPERBLOCK OUTPUTS
-
-    int nOutputs = txNew.vout.size();
-    int nPayments = CountPayments();
-    int nMinerAndMasternodePayments = nOutputs - nPayments;
-
-    LogPrint(BCLog::GOBJECT, "CSuperblock::IsValid -- nOutputs = %d, nPayments = %d, hash = %s\n", nOutputs, nPayments,
-             nGovObjHash.ToString());
-
-    // We require an exact match (including order) between the expected
-    // superblock payments and the payments actually in the block.
-
-    if (nMinerAndMasternodePayments < 0) {
-        // This means the block cannot have all the superblock payments
-        // so it is not valid.
-        // TODO: could that be that we just hit coinbase size limit?
-        LogPrintf("CSuperblock::IsValid -- ERROR: Block invalid, too few superblock payments\n");
-        return false;
-    }
-
-    // payments should not exceed limit
-    CAmount nPaymentsTotalAmount = GetPaymentsTotalAmount();
-    CAmount nPaymentsLimit = GetPaymentsLimit(active_chain, block_height);
-    if (nPaymentsTotalAmount > nPaymentsLimit) {
-        LogPrintf("CSuperblock::IsValid -- ERROR: Block invalid, payments limit exceeded: payments %lld, limit %lld\n", nPaymentsTotalAmount, nPaymentsLimit);
-        return false;
-    }
-
-    // miner and masternodes should not get more than they would usually get
-    CAmount nBlockValue = txNew.GetValueOut();
-    if (nBlockValue > blockReward + nPaymentsTotalAmount) {
-        LogPrintf("CSuperblock::IsValid -- ERROR: Block invalid, block value limit exceeded: block %lld, limit %lld\n", nBlockValue, blockReward + nPaymentsTotalAmount);
-        return false;
-    }
-
-    int nVoutIndex = -1;
-    for (int i = 0; i < nPayments; i++) {
-        CGovernancePayment payment;
-        if (!GetPayment(i, payment)) {
-            // This shouldn't happen so log a warning
-            LogPrintf("CSuperblock::IsValid -- WARNING: Failed to find payment: %d of %d total payments\n", i, nPayments);
-            continue;
-        }
-
-        bool fPaymentMatch = false;
-
-        // From V24 on, start past the previously matched output so each expected
-        // payment consumes a distinct vout (two adjacent payments with the same
-        // script and amount must match two separate outputs, not the same one
-        // twice). Before V24 the scan restarted at the previously matched index
-        // (inclusive), which is kept for backwards compatibility.
-        // TODO: After V24 is hardened/finalized so historical duplicate-output
-        // blocks cannot be encountered, simplify this path to the V24 scan only.
-        const int nVoutStart = is_v24 ? nVoutIndex + 1 : std::max(nVoutIndex, 0);
-        for (int j = nVoutStart; j < nOutputs; j++) {
-            // Find superblock payment
-            fPaymentMatch = ((payment.script == txNew.vout[j].scriptPubKey) &&
-                             (payment.nAmount == txNew.vout[j].nValue));
-
-            if (fPaymentMatch) {
-                nVoutIndex = j;
-                break;
-            }
-        }
-
-        if (!fPaymentMatch) {
-            // Superblock payment not found!
-
-            CTxDestination dest;
-            ExtractDestination(payment.script, dest);
-            LogPrintf("CSuperblock::IsValid -- ERROR: Block invalid: %d payment %d to %s not found\n", i, payment.nAmount, EncodeDestination(dest));
-
-            return false;
-        }
-    }
-
-    return true;
-}
-
 bool CSuperblock::IsExpired(int heightToTest) const
 {
     int nExpirationBlocks;
@@ -575,15 +457,14 @@ bool SuperblockManager::GetBestSuperblockInternal(const CDeterministicMNList& ti
     return nYesCount > 0;
 }
 
-bool SuperblockManager::IsSuperblockTriggered(const CDeterministicMNList& tip_mn_list, int nBlockHeight)
+bool SuperblockManager::IsSuperblockTriggeredInternal(const CDeterministicMNList& tip_mn_list, int nBlockHeight)
 {
+    AssertLockHeld(cs_sb);
     LogPrint(BCLog::GOBJECT, "IsSuperblockTriggered -- Start nBlockHeight = %d\n", nBlockHeight);
     if (!CSuperblock::IsValidBlockHeight(nBlockHeight)) {
         return false;
     }
 
-    LOCK(cs_sb);
-
     LogPrint(BCLog::GOBJECT, "IsSuperblockTriggered -- m_triggers.size() = %d\n", m_triggers.size());
 
     for (const auto& [_, entry] : m_triggers) {
@@ -619,29 +500,24 @@ bool SuperblockManager::IsSuperblockTriggered(const CDeterministicMNList& tip_mn
     return false;
 }
 
-bool SuperblockManager::IsValidSuperblock(const CChain& active_chain, const CDeterministicMNList& tip_mn_list,
-                                          const CTransaction& txNew, int nBlockHeight, CAmount blockReward, bool is_v24) const
+SuperblockStatus SuperblockManager::GetStatus(const CDeterministicMNList& tip_mn_list, int nBlockHeight)
 {
-    LOCK(cs_sb);
-    CSuperblock_sptr pSuperblock;
-    if (GetBestSuperblockInternal(tip_mn_list, pSuperblock, nBlockHeight)) {
-        return pSuperblock->IsValid(active_chain, txNew, nBlockHeight, blockReward, is_v24);
+    SuperblockStatus ret;
+    if (!IsValid()) {
+        return ret;
     }
-    return false;
-}
+    ret.state = SuperblockStatus::State::NotTriggered;
 
-bool SuperblockManager::GetSuperblockPayments(const CDeterministicMNList& tip_mn_list, int nBlockHeight,
-                                              std::vector<CTxOut>& voutSuperblockRet) const
-{
     LOCK(cs_sb);
-
+    if (!IsSuperblockTriggeredInternal(tip_mn_list, nBlockHeight)) {
+        return ret;
+    }
     CSuperblock_sptr pSuperblock;
     if (!GetBestSuperblockInternal(tip_mn_list, pSuperblock, nBlockHeight)) {
-        LogPrint(BCLog::GOBJECT, "GetSuperblockPayments -- Can't find superblock for height %d\n", nBlockHeight);
-        return false;
+        LogPrint(BCLog::GOBJECT, "%s -- Can't find superblock for height %d\n", __func__, nBlockHeight);
+        return ret;
     }
-
-    voutSuperblockRet.clear();
+    ret.state = SuperblockStatus::State::Triggered;
 
     // TODO: How many payments can we add before things blow up?
     //       Consider at least following limits:
@@ -650,19 +526,19 @@ bool SuperblockManager::GetSuperblockPayments(const CDeterministicMNList& tip_mn
     for (int i = 0; i < pSuperblock->CountPayments(); i++) {
         CGovernancePayment payment;
         if (pSuperblock->GetPayment(i, payment)) {
-            voutSuperblockRet.emplace_back(payment.nAmount, payment.script);
+            ret.payments.emplace_back(payment.nAmount, payment.script);
 
             CTxDestination dest;
             ExtractDestination(payment.script, dest);
 
-            LogPrint(BCLog::GOBJECT, "GetSuperblockPayments -- NEW Superblock: output %d (addr %s, amount %d.%08d)\n",
+            LogPrint(BCLog::GOBJECT, "%s -- NEW Superblock: output %d (addr %s, amount %d.%08d)\n", __func__,
                      i, EncodeDestination(dest), payment.nAmount / COIN, payment.nAmount % COIN);
         } else {
-            LogPrint(BCLog::GOBJECT, "GetSuperblockPayments -- Payment not found\n");
+            LogPrint(BCLog::GOBJECT, "%s -- Payment not found\n", __func__);
         }
     }
 
-    return true;
+    return ret;
 }
 
 void SuperblockManager::ExecuteBestSuperblock(const CDeterministicMNList& tip_mn_list, int nBlockHeight)
@@ -670,7 +546,7 @@ void SuperblockManager::ExecuteBestSuperblock(const CDeterministicMNList& tip_mn
     LOCK(cs_sb);
     CSuperblock_sptr pSuperblock;
     if (GetBestSuperblockInternal(tip_mn_list, pSuperblock, nBlockHeight)) {
-        // All checks are done in CSuperblock::IsValid via IsBlockValueValid and IsBlockPayeeValid,
+        // All checks are done in Chainstate::IsBlockValueValid,
         // tip wouldn't be updated if anything was wrong. Mark this trigger as executed.
         pSuperblock->SetExecuted();
     }
diff --git a/src/governance/superblock.h b/src/governance/superblock.h
index 9fb43dc7ce5a..779a2cf93422 100644
--- a/src/governance/superblock.h
+++ b/src/governance/superblock.h
@@ -7,6 +7,7 @@
 
 #include <consensus/amount.h>
 #include <governance/object.h>
+#include <masternode/payments.h>
 #include <script/script.h>
 #include <script/standard.h>
 #include <sync.h>
@@ -18,7 +19,6 @@
 #include <string>
 #include <vector>
 
-class CChain;
 class CDeterministicMNList;
 class CTransaction;
 class CTxOut;
@@ -86,7 +86,7 @@ class CSuperblock : public CGovernanceObject
 
     static bool IsValidBlockHeight(int nBlockHeight);
     static void GetNearestSuperblocksHeights(int nBlockHeight, int& nLastSuperblockRet, int& nNextSuperblockRet);
-    static CAmount GetPaymentsLimit(const CChain& active_chain, int nBlockHeight);
+    static CAmount GetPaymentsLimit(int nBlockHeight);
 
     SeenObjectStatus GetStatus() const { return nStatus; }
     void SetStatus(SeenObjectStatus nStatusIn) { nStatus = nStatusIn; }
@@ -105,9 +105,6 @@ class CSuperblock : public CGovernanceObject
 
     int CountPayments() const { return static_cast<int>(vecPayments.size()); }
     bool GetPayment(int nPaymentIndex, CGovernancePayment& paymentRet);
-    CAmount GetPaymentsTotalAmount();
-
-    bool IsValid(const CChain& active_chain, const CTransaction& txNew, int block_height, CAmount blockReward, bool is_v24);
     bool IsExpired(int heightToTest) const;
 
     std::vector<uint256> GetProposalHashes() const;
@@ -124,7 +121,7 @@ namespace governance {
  * underlying object from its store. Each entry holds a strong reference
  * to the underlying CGovernanceObject so we never look it up by hash.
  *
- * Lifetime: typically owned by CChainstateHelper, which outlives the
+ * Lifetime: owned by NodeContext, which outlives the
  * paired CGovernanceManager. The govman drives m_loaded via SetLoaded()
  * from LoadCache() and Clear()s us in its destructor, so IsValid() and
  * the trigger map track the live govman's state.
@@ -155,13 +152,11 @@ class SuperblockManager
     bool GetBestSuperblock(const CDeterministicMNList& tip_mn_list, CSuperblock_sptr& sbRet, int nBlockHeight) const
         EXCLUSIVE_LOCKS_REQUIRED(!cs_sb);
 
-    bool IsSuperblockTriggered(const CDeterministicMNList& tip_mn_list, int nBlockHeight) EXCLUSIVE_LOCKS_REQUIRED(!cs_sb);
-
-    bool IsValidSuperblock(const CChain& active_chain, const CDeterministicMNList& tip_mn_list, const CTransaction& txNew,
-                           int nBlockHeight, CAmount blockReward, bool is_v24) const EXCLUSIVE_LOCKS_REQUIRED(!cs_sb);
-
-    bool GetSuperblockPayments(const CDeterministicMNList& tip_mn_list, int nBlockHeight,
-                               std::vector<CTxOut>& voutSuperblockRet) const EXCLUSIVE_LOCKS_REQUIRED(!cs_sb);
+    /** Governance's status for the superblock at a height: validation is
+     *  disabled until governance data is loaded; otherwise whether a funded
+     *  trigger exists and, if so, the winning trigger's payment outputs. */
+    SuperblockStatus GetStatus(const CDeterministicMNList& tip_mn_list, int nBlockHeight)
+        EXCLUSIVE_LOCKS_REQUIRED(!cs_sb);
 
     void ExecuteBestSuperblock(const CDeterministicMNList& tip_mn_list, int nBlockHeight) EXCLUSIVE_LOCKS_REQUIRED(!cs_sb);
 
@@ -173,6 +168,8 @@ class SuperblockManager
 
     bool GetBestSuperblockInternal(const CDeterministicMNList& tip_mn_list, CSuperblock_sptr& sbRet,
                                    int nBlockHeight) const EXCLUSIVE_LOCKS_REQUIRED(cs_sb);
+    bool IsSuperblockTriggeredInternal(const CDeterministicMNList& tip_mn_list, int nBlockHeight)
+        EXCLUSIVE_LOCKS_REQUIRED(cs_sb);
 
     mutable Mutex cs_sb;
     std::atomic<bool> m_loaded{false};
diff --git a/src/init.cpp b/src/init.cpp
index aa4d77b639ed..6bdfc03c40f0 100644
--- a/src/init.cpp
+++ b/src/init.cpp
@@ -102,12 +102,12 @@
 #include <coinjoin/server.h>
 #include <coinjoin/walletman.h>
 #include <dsnotificationinterface.h>
-#include <evo/chainhelper.h>
 #include <evo/deterministicmns.h>
 #include <evo/evodb.h>
 #include <evo/specialtxman.h>
 #include <flat-database.h>
 #include <governance/governance.h>
+#include <governance/superblock.h>
 #include <governance/net_governance.h>
 #include <instantsend/instantsend.h>
 #include <instantsend/net_instantsend.h>
@@ -457,7 +457,7 @@ void PrepareShutdown(NodeContext& node)
         // The mempool holds raw pointers to dmnman and isman, so it must be
         // destroyed before either manager.
         node.mempool.reset();
-        node.chain_helper.reset();
+        node.special_tx.reset();
         node.llmq_ctx.reset();
         node.isman.reset();
         node.dmnman.reset();
@@ -1742,6 +1742,18 @@ bool AppInitMain(NodeContext& node, interfaces::BlockAndHeaderTipInfo* tip_info)
     assert(!node.sporkman);
     node.sporkman = std::make_unique<CSporkManager>();
     node.chainlocks = std::make_unique<chainlock::Chainlocks>(*node.sporkman);
+    node.sbman = std::make_unique<governance::SuperblockManager>();
+
+    /**
+     * The manager needs to be constructed regardless of whether governance
+     * validation is needed or not.
+     *
+     * Instead, we decide whether to initialize its database based on whether we
+     * need it or not further down and then query if the database is initialized
+     * to check if validation is enabled.
+     */
+    assert(!node.mn_sync);
+    node.mn_sync = std::make_unique<CMasternodeSync>(std::make_unique<NodeSyncNotifierImpl>(*node.connman, *node.netfulfilledman));
 
     const std::string spork_address{args.GetArg("-sporkaddr", chainparams.SporkAddress())};
     if (args.GetArgs("-sporkaddr").size() > 1) {
@@ -1977,6 +1989,8 @@ bool AppInitMain(NodeContext& node, interfaces::BlockAndHeaderTipInfo* tip_info)
     bool fReindexChainState = args.GetBoolArg("-reindex-chainstate", false);
     ChainstateManager::Options chainman_opts{
         .chainparams = chainparams,
+        .superblock_status = [&sbman = *node.sbman](const CDeterministicMNList& mn_list, int height) { return sbman.GetStatus(mn_list, height); },
+        .mn_sync = node.mn_sync.get(),
     };
     Assert(!ApplyArgsManOptions(args, chainman_opts)); // no error can happen, already checked in AppInitParameterInteraction
 
@@ -2005,7 +2019,6 @@ bool AppInitMain(NodeContext& node, interfaces::BlockAndHeaderTipInfo* tip_info)
 
     assert(!node.mempool);
     assert(!node.chainman);
-    assert(!node.mn_sync);
 
     CTxMemPool::Options mempool_opts{
         .estimator = node.fee_estimator.get(),
@@ -2026,6 +2039,8 @@ bool AppInitMain(NodeContext& node, interfaces::BlockAndHeaderTipInfo* tip_info)
         // On a retry iteration the previous instances still hold the on-disk
         // database locks, so release them before opening the databases again.
         node.mempool.reset();
+        node.special_tx.reset();
+        node.llmq_ctx.reset();
         node.isman.reset();
         node.dmnman.reset();
         node.evodb.reset();
@@ -2051,24 +2066,13 @@ bool AppInitMain(NodeContext& node, interfaces::BlockAndHeaderTipInfo* tip_info)
         node.chainman = std::make_unique<ChainstateManager>(chainman_opts);
         ChainstateManager& chainman = *node.chainman;
 
-        /**
-         * The manager needs to be constructed regardless of whether governance
-         * validation is needed or not.
-         *
-         * Instead, we decide whether to initialize its database based on whether we
-         * need it or not further down and then query if the database is initialized
-         * to check if validation is enabled.
-         */
-        node.mn_sync = std::make_unique<CMasternodeSync>(std::make_unique<NodeSyncNotifierImpl>(*node.connman, *node.netfulfilledman));
-
         node::ChainstateLoadOptions options;
         options.chainlocks = Assert(node.chainlocks.get());
-        options.mn_sync = Assert(node.mn_sync.get());
         options.data_dir = args.GetDataDirNet();
         options.reindex = node::fReindex;
         options.reindex_chainstate = fReindexChainState;
         options.prune = chainman.m_blockman.IsPruneMode();
-        options.bls_threads = [&args]() -> int8_t {
+        const int8_t bls_threads = [&args]() -> int8_t {
             int64_t threads = args.GetIntArg("-parbls", llmq::DEFAULT_BLSCHECK_THREADS);
             if (threads <= 0) {
                 // -parbls=0 means autodetect (number of cores - 1 validator threads)
@@ -2079,7 +2083,7 @@ bool AppInitMain(NodeContext& node, interfaces::BlockAndHeaderTipInfo* tip_info)
             const int64_t adjusted_threads = std::clamp<int64_t>(threads, 1, int64_t{llmq::MAX_BLSCHECK_THREADS} + 1) - 1;
             return static_cast<int8_t>(adjusted_threads);
         }();
-        options.max_recsigs_age = args.GetIntArg("-maxrecsigsage", llmq::DEFAULT_MAX_RECOVERED_SIGS_AGE);
+        const int64_t max_recsigs_age = args.GetIntArg("-maxrecsigsage", llmq::DEFAULT_MAX_RECOVERED_SIGS_AGE);
         options.check_blocks = args.GetIntArg("-checkblocks", DEFAULT_CHECKBLOCKS);
         options.check_level = args.GetIntArg("-checklevel", DEFAULT_CHECKLEVEL);
         options.require_full_verification = args.IsArgSet("-checkblocks") || args.IsArgSet("-checklevel");
@@ -2095,7 +2099,16 @@ bool AppInitMain(NodeContext& node, interfaces::BlockAndHeaderTipInfo* tip_info)
         if (status == node::ChainstateLoadStatus::SUCCESS) {
             options.mempool = Assert(node.mempool.get());
             options.isman = Assert(node.isman.get());
-            std::tie(status, error) = catch_exceptions([&]{ return LoadChainstate(chainman, cache_sizes, options, *node.evodb, *node.dmnman, node.llmq_ctx, node.chain_helper); });
+            std::tie(status, error) = catch_exceptions([&]() -> node::ChainstateLoadResult {
+                WITH_LOCK(::cs_main, node.llmq_ctx = std::make_unique<LLMQContext>(*node.dmnman, *node.evodb, chainman,
+                                                                                   util::DbWrapperParams{.path = args.GetDataDirNet(), .memory = false, .wipe = node::fReindex || fReindexChainState},
+                                                                                   bls_threads, llmq::DEFAULT_WORKER_COUNT, max_recsigs_age));
+                node.special_tx = std::make_unique<CSpecialTxProcessor>(*node.evodb, *node.dmnman,
+                                                                        *node.llmq_ctx->quorum_block_processor, *node.llmq_ctx->qsnapman,
+                                                                        chainman, chainman.m_blockman, chainman.GetConsensus(),
+                                                                        *node.chainlocks, *node.llmq_ctx->qman);
+                return LoadChainstate(chainman, cache_sizes, options, *node.evodb, *node.dmnman, *node.special_tx);
+            });
         }
         if (status == node::ChainstateLoadStatus::SUCCESS) {
             uiInterface.InitMessage(_("Verifying blocks…").translated);
@@ -2153,7 +2166,7 @@ bool AppInitMain(NodeContext& node, interfaces::BlockAndHeaderTipInfo* tip_info)
     RegisterValidationInterface(node.clhandler.get());
 
     assert(!node.govman);
-    node.govman = std::make_unique<CGovernanceManager>(*node.mn_metaman, *node.chainman, *node.chain_helper->superblocks, *node.dmnman, *node.mn_sync);
+    node.govman = std::make_unique<CGovernanceManager>(*node.mn_metaman, *node.chainman, *node.sbman, *node.dmnman, *node.mn_sync);
 
     // ********************************************************* Step 7c: Setup masternode mode or watch-only mode
     assert(!node.active_ctx);
@@ -2170,7 +2183,7 @@ bool AppInitMain(NodeContext& node, interfaces::BlockAndHeaderTipInfo* tip_info)
         }
         // Will init later in ThreadImport
         node.active_ctx = std::make_unique<ActiveContext>(*node.llmq_ctx->bls_worker, chainman, *node.connman, *node.dmnman,
-                                                          *node.govman, *node.chain_helper->superblocks,
+                                                          *node.govman, *node.special_tx->m_mnhfman, *node.sbman,
                                                           *node.sporkman, *node.chainlocks, *node.mempool, *node.clhandler, *node.isman,
                                                           *node.llmq_ctx->qman, *node.llmq_ctx->qsnapman, *node.llmq_ctx->sigman,
                                                           *node.mn_sync, operator_sk, dash_db_params, quorums_watch);
@@ -2517,7 +2530,7 @@ bool AppInitMain(NodeContext& node, interfaces::BlockAndHeaderTipInfo* tip_info)
                                        const CDeterministicMNList& prevList, const CCoinsViewCache& view, bool debugLogs,
                                        BlockValidationState& state, CDeterministicMNList& mnListRet) -> bool {
                     const bool is_v24_active{DeploymentActiveAfter(pindexPrev, chainman, Consensus::DEPLOYMENT_V24)};
-                    return node.chain_helper->special_tx->RebuildListFromBlock(block, pindexPrev, is_v24_active, prevList,
+                    return node.special_tx->RebuildListFromBlock(block, pindexPrev, is_v24_active, prevList,
                                                                                view, debugLogs, state, mnListRet);
                 };
                 auto result = node.dmnman->RecalculateAndRepairDiffs(start_index, stop_index, build_list_func, true);
diff --git a/src/instantsend/instantsend.cpp b/src/instantsend/instantsend.cpp
index 5235b881286d..4c056c1ff797 100644
--- a/src/instantsend/instantsend.cpp
+++ b/src/instantsend/instantsend.cpp
@@ -441,6 +441,22 @@ instantsend::InstantSendLockPtr CInstantSendManager::GetConflictingLock(const CT
     return nullptr;
 }
 
+std::optional<std::pair</*islock_hash=*/uint256, /*txid=*/uint256>> CInstantSendManager::ConflictingISLockIfAny(
+    const CTransaction& tx) const
+{
+    const auto islock = GetConflictingLock(tx);
+    if (!islock) return std::nullopt;
+    return std::make_pair(::SerializeHash(*islock), islock->txid);
+}
+
+bool CInstantSendManager::RemoveConflictingISLockByTx(const CTransaction& tx)
+{
+    const auto islock = GetConflictingLock(tx);
+    if (!islock) return false;
+    RemoveConflictingLock(::SerializeHash(*islock), *islock);
+    return true;
+}
+
 size_t CInstantSendManager::GetInstantSendLockCount() const
 {
     return db.GetInstantSendLockCount();
diff --git a/src/instantsend/instantsend.h b/src/instantsend/instantsend.h
index 4b18c5f1e6ff..82480ffd8dd6 100644
--- a/src/instantsend/instantsend.h
+++ b/src/instantsend/instantsend.h
@@ -16,6 +16,7 @@
 #include <unordered_lru_cache.h>
 
 #include <optional>
+#include <utility>
 #include <vector>
 
 class CBlockIndex;
@@ -118,6 +119,8 @@ class CInstantSendManager
     bool IsLocked(const uint256& txHash) const;
     bool IsWaitingForTx(const uint256& txHash) const EXCLUSIVE_LOCKS_REQUIRED(!cs_pendingLocks);
     instantsend::InstantSendLockPtr GetConflictingLock(const CTransaction& tx) const;
+    std::optional<std::pair</*islock_hash=*/uint256, /*txid=*/uint256>> ConflictingISLockIfAny(const CTransaction& tx) const;
+    bool RemoveConflictingISLockByTx(const CTransaction& tx) EXCLUSIVE_LOCKS_REQUIRED(!cs_height_cache);
 
     /* Helpers for communications between CInstantSendManager & NetInstantSend */
     // This helper returns up to 32 pending locks and remove them from queue of pending
diff --git a/src/instantsend/signing.cpp b/src/instantsend/signing.cpp
index bf5749a174a3..bdd4392d3bda 100644
--- a/src/instantsend/signing.cpp
+++ b/src/instantsend/signing.cpp
@@ -8,7 +8,6 @@
 #include <chainlock/chainlock.h>
 #include <chainparams.h>
 #include <evo/assetlocktx.h>
-#include <evo/chainhelper.h>
 #include <evo/creditpool.h>
 #include <evo/specialtx.h>
 #include <evo/specialtxman.h>
@@ -211,9 +210,8 @@ bool InstantSendSigner::CheckCanLockAssetUnlock(const CTransaction& tx, bool pri
     const CBlockIndex* tip = chainstate.m_chain.Tip();
     // Minable in the next block: inside its height window and signed by a recent quorum
     TxValidationState state;
-    if (!chainstate.ChainHelper().special_tx->CheckSpecialTx(tx, tip, GetSpecialTxRules(tip, m_chainman),
-                                                             chainstate.CoinsTip(),
-                                                             /*check_sigs=*/true, state)) {
+    if (!chainstate.m_special_tx.CheckSpecialTx(tx, tip, GetSpecialTxRules(tip, m_chainman),
+                                                chainstate.CoinsTip(), /*check_sigs=*/true, state)) {
         return log_refusal(state.ToString());
     }
     // Fits the withdrawal limit alongside every other pending withdrawal: the limit is enforced
@@ -225,7 +223,7 @@ bool InstantSendSigner::CheckCanLockAssetUnlock(const CTransaction& tx, bool pri
     // inconsistent pool, EvoDB) refuses this lock rather than escaping into the worker thread.
     CAmount limit{0};
     try {
-        limit = chainstate.ChainHelper().GetCreditPool(tip).currentLimit;
+        limit = chainstate.m_special_tx.m_cpoolman->GetCreditPool(tip).currentLimit;
     } catch (const std::exception& e) {
         LogPrintf("%s -- txid=%s: GetCreditPool failed: %s\n", __func__, tx.GetHash().ToString(), e.what());
         return false;
diff --git a/src/kernel/chainstatemanager_opts.h b/src/kernel/chainstatemanager_opts.h
index a353414d8e99..1ae3637b3700 100644
--- a/src/kernel/chainstatemanager_opts.h
+++ b/src/kernel/chainstatemanager_opts.h
@@ -10,9 +10,13 @@
 #include <util/time.h>
 
 #include <cstdint>
+#include <functional>
 #include <optional>
 
 class CChainParams;
+class CDeterministicMNList;
+class CMasternodeSync;
+struct SuperblockStatus;
 
 static constexpr bool DEFAULT_CHECKPOINTS_ENABLED{true};
 static constexpr auto DEFAULT_MAX_TIP_AGE{6h}; // ~144 blocks behind -> 2 x fork detection time, was 24h in bitcoin
@@ -34,6 +38,12 @@ struct ChainstateManagerOpts {
     std::optional<uint256> assumed_valid_block{};
     //! If the tip is older than this, the node is considered to be in initial block download.
     std::chrono::seconds max_tip_age{DEFAULT_MAX_TIP_AGE};
+    //! Dash: governance's superblock status for a block height, consulted by
+    //! block validation and the miner. Unset means superblock validation is disabled.
+    std::function<SuperblockStatus(const CDeterministicMNList& mn_list, int nBlockHeight)> superblock_status{};
+    //! Dash: sync state gating superblock enforcement; must stay valid while
+    //! blocks are connected. Unset counts as not synced, so nothing is enforced.
+    const CMasternodeSync* mn_sync{nullptr};
 };
 
 } // namespace kernel
diff --git a/src/llmq/ehf_signals.cpp b/src/llmq/ehf_signals.cpp
index fc8563fdc197..f156b6f8c2c2 100644
--- a/src/llmq/ehf_signals.cpp
+++ b/src/llmq/ehf_signals.cpp
@@ -7,7 +7,6 @@
 #include <chainparams.h>
 #include <consensus/validation.h>
 #include <deploymentstatus.h>
-#include <evo/chainhelper.h>
 #include <evo/mnhftx.h>
 #include <index/txindex.h> // g_txindex
 #include <llmq/commitment.h>
@@ -18,9 +17,10 @@
 #include <versionbits.h>
 
 namespace llmq {
-CEHFSignalsHandler::CEHFSignalsHandler(ChainstateManager& chainman, CSigningManager& sigman,
+CEHFSignalsHandler::CEHFSignalsHandler(ChainstateManager& chainman, CMNHFManager& mnhfman, CSigningManager& sigman,
                                        CSigSharesManager& shareman, const CQuorumManager& qman) :
     m_chainman(chainman),
+    m_mnhfman(mnhfman),
     sigman(sigman),
     shareman(shareman),
     qman(qman)
@@ -43,7 +43,7 @@ void CEHFSignalsHandler::UpdatedBlockTip(const CBlockIndex* const pindexNew)
 {
     if (!DeploymentActiveAfter(pindexNew, Params().GetConsensus(), Consensus::DEPLOYMENT_V20)) return;
 
-    const auto ehfSignals = m_chainman.ActiveChainstate().ChainHelper().ehf_manager->GetSignalsStage(pindexNew);
+    const auto ehfSignals = m_mnhfman.GetSignalsStage(pindexNew);
     const int64_t time_past = pindexNew->GetMedianTimePast();
     for (int i = 0; i < Consensus::MAX_VERSION_BITS_DEPLOYMENTS; ++i) {
         const auto pos{static_cast<Consensus::DeploymentPos>(i)};
@@ -108,8 +108,7 @@ RecoveredSigResult CEHFSignalsHandler::HandleNewRecoveredSig(const CRecoveredSig
         return std::monostate{};
     }
 
-    const auto ehfSignals = m_chainman.ActiveChainstate().ChainHelper().ehf_manager->GetSignalsStage(
-        WITH_LOCK(::cs_main, return m_chainman.ActiveTip()));
+    const auto ehfSignals = m_mnhfman.GetSignalsStage(WITH_LOCK(::cs_main, return m_chainman.ActiveTip()));
     MNHFTxPayload mnhfPayload;
     for (const auto& deployment : Params().GetConsensus().vDeployments) {
         // skip deployments that do not use dip0023 or that have already been mined
diff --git a/src/llmq/ehf_signals.h b/src/llmq/ehf_signals.h
index 12b7cb26f655..c1a4f5abf851 100644
--- a/src/llmq/ehf_signals.h
+++ b/src/llmq/ehf_signals.h
@@ -12,6 +12,7 @@
 
 class CBlockIndex;
 class ChainstateManager;
+class CMNHFManager;
 
 namespace llmq {
 class CQuorumManager;
@@ -22,6 +23,7 @@ class CEHFSignalsHandler : public CRecoveredSigsListener
 {
 private:
     ChainstateManager& m_chainman;
+    CMNHFManager& m_mnhfman;
     CSigningManager& sigman;
     CSigSharesManager& shareman;
     const CQuorumManager& qman;
@@ -33,8 +35,8 @@ class CEHFSignalsHandler : public CRecoveredSigsListener
     Uint256HashSet ids GUARDED_BY(cs);
 
 public:
-    explicit CEHFSignalsHandler(ChainstateManager& chainman, CSigningManager& sigman, CSigSharesManager& shareman,
-                                const CQuorumManager& qman);
+    explicit CEHFSignalsHandler(ChainstateManager& chainman, CMNHFManager& mnhfman, CSigningManager& sigman,
+                                CSigSharesManager& shareman, const CQuorumManager& qman);
 
     ~CEHFSignalsHandler() override;
 
diff --git a/src/masternode/payments.cpp b/src/masternode/payments.cpp
index b2eebcf2aea2..546971a286de 100644
--- a/src/masternode/payments.cpp
+++ b/src/masternode/payments.cpp
@@ -5,21 +5,18 @@
 #include <masternode/payments.h>
 
 #include <evo/deterministicmns.h>
-#include <governance/superblock.h>
-#include <masternode/sync.h>
 
 #include <chain.h>
 #include <consensus/amount.h>
-#include <deploymentstatus.h>
+#include <consensus/params.h>
 #include <key_io.h>
 #include <logging.h>
-#include <primitives/block.h>
 #include <script/standard.h>
-#include <tinyformat.h>
+#include <util/std23.h>
 
+#include <algorithm>
 #include <cassert>
 #include <ranges>
-#include <string>
 
 int FindUnmatchedMasternodePayment(const std::vector<CTxOut>& expected,
                                    const std::vector<CTxOut>& actual,
@@ -128,33 +125,116 @@ CAmount GetMasternodePayment(int nHeight, CAmount blockValue, const Consensus::P
     return static_cast<CAmount>(blockValue * vecPeriods[nCurrentPeriod] / 1000);
 }
 
-[[nodiscard]] bool CMNPaymentsProcessor::GetBlockTxOuts(const CBlockIndex* pindexPrev, const CAmount blockSubsidy, const CAmount feeReward,
-                                                        MnRewardEra era, std::vector<CTxOut>& voutMasternodePaymentsRet)
+bool IsSuperblockHeight(const int nBlockHeight, const Consensus::Params& consensus_params)
+{
+    // SUPERBLOCKS CAN HAPPEN ONLY after hardfork and only ONCE PER CYCLE
+    return nBlockHeight >= consensus_params.nSuperblockStartBlock &&
+           ((nBlockHeight % consensus_params.nSuperblockCycle) == 0);
+}
+
+bool IsSuperblockValid(const SuperblockStatus& superblock, const CTransaction& txNew, CAmount blockReward, bool is_v24, CAmount nPaymentsLimit)
+{
+    const std::vector<CTxOut>& payments{superblock.payments};
+
+    // CONFIGURE SUPERBLOCK OUTPUTS
+
+    int nOutputs = txNew.vout.size();
+    int nPayments = payments.size();
+    int nMinerAndMasternodePayments = nOutputs - nPayments;
+
+    LogPrint(BCLog::GOBJECT, "%s -- nOutputs = %d, nPayments = %d\n", __func__, nOutputs, nPayments);
+
+    // We require an exact match (including order) between the expected
+    // superblock payments and the payments actually in the block.
+
+    if (nMinerAndMasternodePayments < 0) {
+        // This means the block cannot have all the superblock payments
+        // so it is not valid.
+        // TODO: could that be that we just hit coinbase size limit?
+        LogPrintf("%s -- ERROR: Block invalid, too few superblock payments\n", __func__);
+        return false;
+    }
+
+    // payments should not exceed limit
+    CAmount nPaymentsTotalAmount = std23::ranges::fold_left(payments, CAmount{0}, [](CAmount s, const auto& p) { return s + p.nValue; });
+    if (nPaymentsTotalAmount > nPaymentsLimit) {
+        LogPrintf("%s -- ERROR: Block invalid, payments limit exceeded: payments %lld, limit %lld\n", __func__, nPaymentsTotalAmount, nPaymentsLimit);
+        return false;
+    }
+
+    // miner and masternodes should not get more than they would usually get
+    CAmount nBlockValue = txNew.GetValueOut();
+    if (nBlockValue > blockReward + nPaymentsTotalAmount) {
+        LogPrintf("%s -- ERROR: Block invalid, block value limit exceeded: block %lld, limit %lld\n", __func__, nBlockValue, blockReward + nPaymentsTotalAmount);
+        return false;
+    }
+
+    int nVoutIndex = -1;
+    for (int i = 0; i < nPayments; i++) {
+        const CTxOut& payment = payments[i];
+        bool fPaymentMatch = false;
+
+        // From V24 on, start past the previously matched output so each expected
+        // payment consumes a distinct vout (two adjacent payments with the same
+        // script and amount must match two separate outputs, not the same one
+        // twice). Before V24 the scan restarted at the previously matched index
+        // (inclusive), which is kept for backwards compatibility.
+        // TODO: After V24 is hardened/finalized so historical duplicate-output
+        // blocks cannot be encountered, simplify this path to the V24 scan only.
+        const int nVoutStart = is_v24 ? nVoutIndex + 1 : std::max(nVoutIndex, 0);
+        for (int j = nVoutStart; j < nOutputs; j++) {
+            // Find superblock payment
+            fPaymentMatch = ((payment.scriptPubKey == txNew.vout[j].scriptPubKey) &&
+                             (payment.nValue == txNew.vout[j].nValue));
+
+            if (fPaymentMatch) {
+                nVoutIndex = j;
+                break;
+            }
+        }
+
+        if (!fPaymentMatch) {
+            // Superblock payment not found!
+
+            CTxDestination dest;
+            ExtractDestination(payment.scriptPubKey, dest);
+            LogPrintf("%s -- ERROR: Block invalid: %d payment %d to %s not found\n", __func__, i, payment.nValue, EncodeDestination(dest));
+
+            return false;
+        }
+    }
+
+    return true;
+}
+
+bool GetMasternodePayments(const CDeterministicMNList& mn_list, const CBlockIndex* pindexPrev,
+                           const CAmount blockSubsidy, const CAmount feeReward, MnRewardEra era,
+                           const Consensus::Params& consensus_params,
+                           std::vector<CTxOut>& voutMasternodePaymentsRet)
 {
     voutMasternodePaymentsRet.clear();
 
     const int nBlockHeight = pindexPrev  == nullptr ? 0 : pindexPrev->nHeight + 1;
 
-    CAmount masternodeReward = GetMasternodePayment(nBlockHeight, blockSubsidy + feeReward, m_consensus_params, era);
+    CAmount masternodeReward = GetMasternodePayment(nBlockHeight, blockSubsidy + feeReward, consensus_params, era);
 
     // Credit Pool doesn't exist before V20. If any part of reward will re-allocated to credit pool before v20
     // activation these fund will be just permanently lost. Applicable for devnets, regtest, testnet
     if (era == MnRewardEra::EvoReward) {
-        CAmount masternodeSubsidyReward = GetMasternodePayment(nBlockHeight, blockSubsidy, m_consensus_params, era);
+        CAmount masternodeSubsidyReward = GetMasternodePayment(nBlockHeight, blockSubsidy, consensus_params, era);
         const CAmount platformReward = PlatformShare(masternodeSubsidyReward);
         masternodeReward -= platformReward;
 
         assert(MoneyRange(masternodeReward));
 
-        LogPrint(BCLog::MNPAYMENTS, "CMNPaymentsProcessor::%s -- MN reward %lld reallocated to credit pool\n", __func__, platformReward);
+        LogPrint(BCLog::MNPAYMENTS, "%s -- MN reward %lld reallocated to credit pool\n", __func__, platformReward);
         voutMasternodePaymentsRet.emplace_back(platformReward, CScript() << OP_RETURN);
     }
-    const auto mnList = m_dmnman.GetListForBlock(pindexPrev);
-    if (mnList.GetCounts().total() == 0) {
-        LogPrint(BCLog::MNPAYMENTS, "CMNPaymentsProcessor::%s -- no masternode registered to receive a payment\n", __func__);
+    if (mn_list.GetCounts().total() == 0) {
+        LogPrint(BCLog::MNPAYMENTS, "%s -- no masternode registered to receive a payment\n", __func__);
         return true;
     }
-    const auto dmnPayee = mnList.GetMNPayee(pindexPrev);
+    const auto dmnPayee = mn_list.GetMNPayee(pindexPrev);
     if (!dmnPayee) {
         return false;
     }
@@ -197,278 +277,3 @@ CAmount GetMasternodePayment(int nHeight, CAmount blockValue, const Consensus::P
 
     return true;
 }
-
-/**
-*   GetMasternodeTxOuts
-*
-*   Get masternode payment tx outputs
-*/
-[[nodiscard]] bool CMNPaymentsProcessor::GetMasternodeTxOuts(const CBlockIndex* pindexPrev, const CAmount blockSubsidy, const CAmount feeReward,
-                                                             MnRewardEra era, std::vector<CTxOut>& voutMasternodePaymentsRet)
-{
-    // make sure it's not filled yet
-    voutMasternodePaymentsRet.clear();
-
-    if(!GetBlockTxOuts(pindexPrev, blockSubsidy, feeReward, era, voutMasternodePaymentsRet)) {
-        LogPrintf("CMNPaymentsProcessor::%s -- ERROR Failed to get payee\n", __func__);
-        return false;
-    }
-
-    for (const auto& txout : voutMasternodePaymentsRet) {
-        CTxDestination dest;
-        ExtractDestination(txout.scriptPubKey, dest);
-
-        LogPrintf("CMNPaymentsProcessor::%s -- Masternode payment %lld to %s\n", __func__, txout.nValue, EncodeDestination(dest));
-    }
-
-    return true;
-}
-
-[[nodiscard]] bool CMNPaymentsProcessor::IsTransactionValid(const CTransaction& txNew, const CBlockIndex* pindexPrev, const CAmount blockSubsidy,
-                                                            const CAmount feeReward, MnRewardEra era, bool strict_multiplicity)
-{
-    const int nBlockHeight = pindexPrev  == nullptr ? 0 : pindexPrev->nHeight + 1;
-    if (!DeploymentDIP0003Enforced(nBlockHeight, m_consensus_params)) {
-        // can't verify historical blocks here
-        return true;
-    }
-
-    std::vector<CTxOut> voutMasternodePayments;
-    if (!GetBlockTxOuts(pindexPrev, blockSubsidy, feeReward, era, voutMasternodePayments)) {
-        LogPrintf("CMNPaymentsProcessor::%s -- ERROR! Failed to get payees for block at height %s\n", __func__, nBlockHeight);
-        return true;
-    }
-
-    // With strict multiplicity (v24 active, computed by the caller) each expected payment must be
-    // matched by a distinct coinbase output: duplicate expected outputs require duplicate coinbase
-    // outputs. Pre-v24 retains the legacy existence-only check to avoid tightening historical
-    // validation.
-    const int unmatched_idx = FindUnmatchedMasternodePayment(voutMasternodePayments, txNew.vout, strict_multiplicity);
-    if (unmatched_idx >= 0) {
-        const auto& txout = voutMasternodePayments[unmatched_idx];
-        std::string str_payout;
-        if (CTxDestination dest; ExtractDestination(txout.scriptPubKey, dest)) {
-            str_payout = "address=" + EncodeDestination(dest);
-        } else {
-            str_payout = "scriptPubKey=" + HexStr(txout.scriptPubKey);
-        }
-        LogPrintf("CMNPaymentsProcessor::%s -- ERROR! Failed to find expected payee %s amount=%lld height=%d\n",
-                  __func__, str_payout, txout.nValue, nBlockHeight);
-        return false;
-    }
-    return true;
-}
-
-[[nodiscard]] bool CMNPaymentsProcessor::IsOldBudgetBlockValueValid(const CBlock& block, const int nBlockHeight, const CAmount blockReward, std::string& strErrorRet, SuperBlockCheckType check_superblock)
-{
-    bool isBlockRewardValueMet = (block.vtx[0]->GetValueOut() <= blockReward);
-
-    if (nBlockHeight < m_consensus_params.nBudgetPaymentsStartBlock) {
-        strErrorRet = strprintf("Incorrect block %d, old budgets are not activated yet", nBlockHeight);
-        return false;
-    }
-
-    if (nBlockHeight >= m_consensus_params.nSuperblockStartBlock) {
-        strErrorRet = strprintf("Incorrect block %d, old budgets are no longer active", nBlockHeight);
-        return false;
-    }
-
-    // we are still using budgets, but we have no data about them anymore,
-    // all we know is predefined budget cycle and window
-
-    int nOffset = nBlockHeight % m_consensus_params.nBudgetPaymentsCycleBlocks;
-    if (nOffset < m_consensus_params.nBudgetPaymentsWindowBlocks) {
-        // NOTE: old budget system is disabled since 12.1
-        if (check_superblock == SuperBlockCheckType::NoCheck) {
-            // historical mainnet blocks in this window do pay old budgets and we have no
-            // data to validate them with, so rely on online nodes (all networks)
-            LogPrint(BCLog::GOBJECT, "CMNPaymentsProcessor::%s -- WARNING! Skipping old budget block value checks, accepting block\n", __func__);
-            return true;
-        }
-        // no old budget blocks should be accepted here on mainnet,
-        // testnet/devnet/regtest should produce regular blocks only
-        if(!isBlockRewardValueMet) {
-            strErrorRet = strprintf("coinbase pays too much at height %d (actual=%d vs limit=%d), exceeded block reward, old budgets are disabled",
-                                    nBlockHeight, block.vtx[0]->GetValueOut(), blockReward);
-        }
-        return isBlockRewardValueMet;
-    }
-    if(!isBlockRewardValueMet) {
-        strErrorRet = strprintf("coinbase pays too much at height %d (actual=%d vs limit=%d), exceeded block reward, block is not in old budget cycle window",
-                                nBlockHeight, block.vtx[0]->GetValueOut(), blockReward);
-    }
-    return isBlockRewardValueMet;
-}
-
-/**
-* IsBlockValueValid
-*
-*   Determine if coinbase outgoing created money is the correct value
-*
-*   Why is this needed?
-*   - In Dash some blocks are superblocks, which output much higher amounts of coins
-*   - Other blocks are 10% lower in outgoing value, so in total, no extra coins are created
-*   - When non-superblocks are detected, the normal schedule should be maintained
-*/
-bool CMNPaymentsProcessor::IsBlockValueValid(const CChain& active_chain, const CBlock& block, const CBlockIndex* pindexPrev, const CAmount blockReward, std::string& strErrorRet, SuperBlockCheckType check_superblock)
-{
-    const int nBlockHeight = pindexPrev == nullptr ? 0 : pindexPrev->nHeight + 1;
-    bool isBlockRewardValueMet = (block.vtx[0]->GetValueOut() <= blockReward);
-
-    strErrorRet = "";
-
-    if (nBlockHeight < m_consensus_params.nBudgetPaymentsStartBlock) {
-        // old budget system is not activated yet, just make sure we do not exceed the regular block reward
-        if(!isBlockRewardValueMet) {
-            strErrorRet = strprintf("coinbase pays too much at height %d (actual=%d vs limit=%d), exceeded block reward, old budgets are not activated yet",
-                                    nBlockHeight, block.vtx[0]->GetValueOut(), blockReward);
-        }
-        return isBlockRewardValueMet;
-    } else if (nBlockHeight < m_consensus_params.nSuperblockStartBlock) {
-        // superblocks are not enabled yet, check if we can pass old budget rules
-        return IsOldBudgetBlockValueValid(block, nBlockHeight, blockReward, strErrorRet, check_superblock);
-    }
-
-    LogPrint(BCLog::MNPAYMENTS, "block.vtx[0]->GetValueOut() %lld <= blockReward %lld\n", block.vtx[0]->GetValueOut(), blockReward);
-
-    CAmount nSuperblockMaxValue =  blockReward + CSuperblock::GetPaymentsLimit(active_chain, nBlockHeight);
-    bool isSuperblockMaxValueMet = (block.vtx[0]->GetValueOut() <= nSuperblockMaxValue);
-
-    LogPrint(BCLog::GOBJECT, "block.vtx[0]->GetValueOut() %lld <= nSuperblockMaxValue %lld\n", block.vtx[0]->GetValueOut(), nSuperblockMaxValue);
-
-    if (!CSuperblock::IsValidBlockHeight(nBlockHeight)) {
-        // can't possibly be a superblock, so lets just check for block reward limits
-        if (!isBlockRewardValueMet) {
-            strErrorRet = strprintf("coinbase pays too much at height %d (actual=%d vs limit=%d), exceeded block reward, only regular blocks are allowed at this height",
-                                    nBlockHeight, block.vtx[0]->GetValueOut(), blockReward);
-        }
-        return isBlockRewardValueMet;
-    }
-
-    // bail out in case superblock limits were exceeded
-    if (!isSuperblockMaxValueMet) {
-        strErrorRet = strprintf("coinbase pays too much at height %d (actual=%d vs limit=%d), exceeded superblock max value",
-                                nBlockHeight, block.vtx[0]->GetValueOut(), nSuperblockMaxValue);
-        return false;
-    }
-
-    if (!m_superblocks.IsValid()) {
-        LogPrint(BCLog::MNPAYMENTS, "CMNPaymentsProcessor::%s -- WARNING! Not enough data, checked superblock max bounds only\n", __func__);
-        // not enough data for full checks but at least we know that the superblock limits were honored.
-        // We rely on the network to have followed the correct chain in this case
-        return true;
-    }
-
-    if (check_superblock == SuperBlockCheckType::NoCheck) return true;
-
-    // we are synced and possibly on a superblock now
-
-    const auto tip_mn_list = m_dmnman.GetListAtChainTip();
-
-    if (!m_superblocks.IsSuperblockTriggered(tip_mn_list, nBlockHeight)) {
-        // we are on a valid superblock height but a superblock was not triggered
-        // revert to block reward limits in this case
-        if(!isBlockRewardValueMet) {
-            strErrorRet = strprintf("coinbase pays too much at height %d (actual=%d vs limit=%d), exceeded block reward, no triggered superblock detected",
-                                    nBlockHeight, block.vtx[0]->GetValueOut(), blockReward);
-        }
-        return isBlockRewardValueMet;
-    }
-
-    // this actually also checks for correct payees and not only amount
-    const bool is_v24{check_superblock == SuperBlockCheckType::DisallowDuplicates};
-    if (!m_superblocks.IsValidSuperblock(active_chain, tip_mn_list, *block.vtx[0], nBlockHeight, blockReward, is_v24)) {
-        // triggered but invalid? that's weird
-        LogPrintf("CMNPaymentsProcessor::%s -- ERROR! Invalid superblock detected at height %d: %s", __func__, nBlockHeight, block.vtx[0]->ToString()); /* Continued */
-        // should NOT allow invalid superblocks, when superblocks are enabled
-        strErrorRet = strprintf("invalid superblock detected at height %d", nBlockHeight);
-        return false;
-    }
-
-    // we got a valid superblock
-    return true;
-}
-
-bool CMNPaymentsProcessor::IsBlockPayeeValid(const CChain& active_chain, const CTransaction& txNew, const CBlockIndex* pindexPrev, const CAmount blockSubsidy, const CAmount feeReward, MnRewardEra era, bool strict_multiplicity, SuperBlockCheckType check_superblock)
-{
-    const int nBlockHeight = pindexPrev  == nullptr ? 0 : pindexPrev->nHeight + 1;
-
-    // Check for correct masternode payment
-    if (IsTransactionValid(txNew, pindexPrev, blockSubsidy, feeReward, era, strict_multiplicity)) {
-        LogPrint(BCLog::MNPAYMENTS, "CMNPaymentsProcessor::%s -- Valid masternode payment at height %d: %s", __func__, nBlockHeight, txNew.ToString()); /* Continued */
-    } else {
-        LogPrintf("CMNPaymentsProcessor::%s -- ERROR! Invalid masternode payment detected at height %d: %s", __func__, nBlockHeight, txNew.ToString()); /* Continued */
-        return false;
-    }
-
-    if (!m_superblocks.IsValid()) {
-        // governance data is either incomplete or non-existent
-        LogPrint(BCLog::MNPAYMENTS, "CMNPaymentsProcessor::%s -- WARNING! Not enough data, skipping superblock payee checks\n", __func__);
-        return true;  // not an error
-    }
-
-    if (nBlockHeight < m_consensus_params.nSuperblockStartBlock) {
-        // We are still using budgets, but we have no data about them anymore,
-        // we can only check masternode payments.
-        // NOTE: old budget system is disabled since 12.1 and we should never enter this branch
-        // anymore when sync is finished (on mainnet). We have no old budget data but these blocks
-        // have tons of confirmations and can be safely accepted without payee verification
-        LogPrint(BCLog::GOBJECT, "CMNPaymentsProcessor::%s -- WARNING! Client synced but old budget system is disabled, accepting any payee\n", __func__);
-        return true; // not an error
-    }
-
-    // superblocks started
-    if (check_superblock == SuperBlockCheckType::NoCheck) return true;
-
-    const auto tip_mn_list = m_dmnman.GetListAtChainTip();
-    const bool is_v24{check_superblock == SuperBlockCheckType::DisallowDuplicates};
-    if (m_superblocks.IsSuperblockTriggered(tip_mn_list, nBlockHeight)) {
-        if (m_superblocks.IsValidSuperblock(active_chain, tip_mn_list, txNew, nBlockHeight,
-                                            blockSubsidy + feeReward, is_v24)) {
-            LogPrint(BCLog::GOBJECT, "CMNPaymentsProcessor::%s -- Valid superblock at height %d: %s", /* Continued */
-                     __func__, nBlockHeight, txNew.ToString());
-            // continue validation, should also pay MN
-        } else {
-            LogPrintf("CMNPaymentsProcessor::%s -- ERROR! Invalid superblock detected at height %d: %s", /* Continued */
-                      __func__, nBlockHeight, txNew.ToString());
-            return false;
-        }
-    } else {
-        LogPrint(BCLog::GOBJECT, "CMNPaymentsProcessor::%s -- No triggered superblock detected at height %d\n",
-                 __func__, nBlockHeight);
-    }
-
-    return true;
-}
-
-void CMNPaymentsProcessor::FillBlockPayments(CMutableTransaction& txNew, const CBlockIndex* pindexPrev, const CAmount blockSubsidy, const CAmount feeReward,
-                                             MnRewardEra era, std::vector<CTxOut>& voutMasternodePaymentsRet, std::vector<CTxOut>& voutSuperblockPaymentsRet)
-{
-    int nBlockHeight = pindexPrev == nullptr ? 0 : pindexPrev->nHeight + 1;
-
-    // Only create superblocks when one is actually triggered.
-    const auto tip_mn_list = m_dmnman.GetListAtChainTip();
-    if (m_superblocks.IsSuperblockTriggered(tip_mn_list, nBlockHeight)) {
-        LogPrint(BCLog::GOBJECT, "CMNPaymentsProcessor::%s -- Triggered superblock creation at height %d\n", __func__, nBlockHeight);
-        m_superblocks.GetSuperblockPayments(tip_mn_list, nBlockHeight, voutSuperblockPaymentsRet);
-    }
-
-    if (!GetMasternodeTxOuts(pindexPrev, blockSubsidy, feeReward, era, voutMasternodePaymentsRet)) {
-        LogPrint(BCLog::MNPAYMENTS, "CMNPaymentsProcessor::%s -- No masternode to pay (MN list probably empty)\n", __func__);
-    }
-
-    txNew.vout.insert(txNew.vout.end(), voutMasternodePaymentsRet.begin(), voutMasternodePaymentsRet.end());
-    txNew.vout.insert(txNew.vout.end(), voutSuperblockPaymentsRet.begin(), voutSuperblockPaymentsRet.end());
-
-    std::string voutMasternodeStr;
-    for (const auto& txout : voutMasternodePaymentsRet) {
-        // subtract MN payment from miner reward
-        txNew.vout[0].nValue -= txout.nValue;
-        if (!voutMasternodeStr.empty())
-            voutMasternodeStr += ",";
-        voutMasternodeStr += txout.ToString();
-    }
-
-    LogPrint(BCLog::MNPAYMENTS, "CMNPaymentsProcessor::%s -- nBlockHeight %d blockReward %lld voutMasternodePaymentsRet \"%s\" txNew %s", __func__, /* Continued */
-                            nBlockHeight, blockSubsidy + feeReward, voutMasternodeStr, txNew.ToString());
-}
diff --git a/src/masternode/payments.h b/src/masternode/payments.h
index a24cc4808f07..6c651e2a6bd6 100644
--- a/src/masternode/payments.h
+++ b/src/masternode/payments.h
@@ -6,16 +6,12 @@
 #define BITCOIN_MASTERNODE_PAYMENTS_H
 
 #include <consensus/amount.h>
+#include <primitives/transaction.h>
 
-#include <string>
 #include <vector>
 
-class CBlock;
 class CBlockIndex;
-class CChain;
-class CDeterministicMNManager;
-class CTransaction;
-class CTxOut;
+class CDeterministicMNList;
 
 /**
  * Match the list of expected masternode payment outputs against the coinbase
@@ -36,11 +32,6 @@ int FindUnmatchedMasternodePayment(const std::vector<CTxOut>& expected,
                                    const std::vector<CTxOut>& actual,
                                    bool strict_multiplicity);
 
-struct CMutableTransaction;
-
-namespace governance {
-class SuperblockManager;
-}
 namespace Consensus { struct Params; }
 
 /**
@@ -63,43 +54,43 @@ enum class MnRewardEra {
     EvoReward,  // MN_RR: platform share is reallocated from the masternode reward
 };
 
-enum class SuperBlockCheckType {
-    NoCheck, // for chainlocked blocks or during sync
-    AllowDuplicates,
-    DisallowDuplicates,
-};
-
 CAmount GetMasternodePayment(int nHeight, CAmount blockValue, const Consensus::Params& consensus_params, MnRewardEra era);
 
-class CMNPaymentsProcessor
-{
-private:
-    CDeterministicMNManager& m_dmnman;
-    governance::SuperblockManager& m_superblocks;
-    const Consensus::Params& m_consensus_params;
-
-private:
-    [[nodiscard]] bool GetBlockTxOuts(const CBlockIndex* pindexPrev, const CAmount blockSubsidy, const CAmount feeReward,
-                                      MnRewardEra era, std::vector<CTxOut>& voutMasternodePaymentsRet);
-    [[nodiscard]] bool GetMasternodeTxOuts(const CBlockIndex* pindexPrev, const CAmount blockSubsidy, const CAmount feeReward,
-                                      MnRewardEra era, std::vector<CTxOut>& voutMasternodePaymentsRet);
-    [[nodiscard]] bool IsTransactionValid(const CTransaction& txNew, const CBlockIndex* pindexPrev, const CAmount blockSubsidy,
-                                          const CAmount feeReward, MnRewardEra era, bool strict_multiplicity);
-    [[nodiscard]] bool IsOldBudgetBlockValueValid(const CBlock& block, const int nBlockHeight, const CAmount blockReward, std::string& strErrorRet, SuperBlockCheckType check_superblock);
-
-public:
-    explicit CMNPaymentsProcessor(CDeterministicMNManager& dmnman, governance::SuperblockManager& superblocks,
-                                  const Consensus::Params& consensus_params) :
-        m_dmnman{dmnman},
-        m_superblocks{superblocks},
-        m_consensus_params{consensus_params}
-    {
-    }
-
-    bool IsBlockValueValid(const CChain& active_chain, const CBlock& block, const CBlockIndex* pindexPrev, const CAmount blockReward, std::string& strErrorRet, SuperBlockCheckType check_superblock);
-    bool IsBlockPayeeValid(const CChain& active_chain, const CTransaction& txNew, const CBlockIndex* pindexPrev, const CAmount blockSubsidy, const CAmount feeReward, MnRewardEra era, bool strict_multiplicity, SuperBlockCheckType check_superblock);
-    void FillBlockPayments(CMutableTransaction& txNew, const CBlockIndex* pindexPrev, const CAmount blockSubsidy, const CAmount feeReward,
-                           MnRewardEra era, std::vector<CTxOut>& voutMasternodePaymentsRet, std::vector<CTxOut>& voutSuperblockPaymentsRet);
+/**
+ * Expected masternode payment outputs for the block after @p pindexPrev,
+ * derived from the deterministic masternode list at @p pindexPrev.
+ *
+ * Returns false when the list has entries but no payee could be determined;
+ * @p voutMasternodePaymentsRet may already carry the platform reallocation
+ * output in that case.
+ */
+bool GetMasternodePayments(const CDeterministicMNList& mn_list, const CBlockIndex* pindexPrev,
+                           CAmount blockSubsidy, CAmount feeReward, MnRewardEra era,
+                           const Consensus::Params& consensus_params,
+                           std::vector<CTxOut>& voutMasternodePaymentsRet);
+
+/** Superblocks happen once per cycle after the superblock hardfork. */
+bool IsSuperblockHeight(int nBlockHeight, const Consensus::Params& consensus_params);
+
+/** What governance says about the superblock at a block height. */
+struct SuperblockStatus {
+    enum class State {
+        //! governance data is not loaded, so only the superblock value bounds can be checked
+        ValidationDisabled,
+        //! no funded superblock trigger exists for the height
+        NotTriggered,
+        //! a funded trigger exists; payments holds the winning trigger's outputs, in order
+        Triggered,
+    };
+    State state{State::ValidationDisabled};
+    std::vector<CTxOut> payments;
 };
 
+/**
+ * Whether the coinbase @p txNew carries every payment of the triggered
+ * @p superblock, in order, within the superblock payments limit, and pays
+ * out no more than @p blockReward on top of them.
+ */
+bool IsSuperblockValid(const SuperblockStatus& superblock, const CTransaction& txNew, CAmount blockReward, bool is_v24, CAmount nPaymentsLimit);
+
 #endif // BITCOIN_MASTERNODE_PAYMENTS_H
diff --git a/src/node/chainstate.cpp b/src/node/chainstate.cpp
index 35c676617b1c..d270725d05dd 100644
--- a/src/node/chainstate.cpp
+++ b/src/node/chainstate.cpp
@@ -25,12 +25,11 @@
 #include <validation.h>
 
 #include <bls/bls.h>
-#include <evo/chainhelper.h>
 #include <evo/deterministicmns.h>
 #include <evo/evodb.h>
 #include <evo/mnhftx.h>
+#include <evo/specialtxman.h>
 #include <gsl/pointers.h>
-#include <llmq/context.h>
 
 #include <atomic>
 #include <cassert>
@@ -142,30 +141,15 @@ static bool RecoverSnapshotCleanup(CEvoDB& evodb, const fs::path& data_dir, bili
 static ChainstateLoadResult CompleteChainstateInitialization(ChainstateManager& chainman, const CacheSizes& cache_sizes,
                                                              const ChainstateLoadOptions& options, CEvoDB& evodb,
                                                              CDeterministicMNManager& dmnman,
-                                                             std::unique_ptr<LLMQContext>& llmq_ctx,
-                                                             std::unique_ptr<CChainstateHelper>& chain_helper)
+                                                             CSpecialTxProcessor& special_tx)
     EXCLUSIVE_LOCKS_REQUIRED(::cs_main)
 {
-    const bool to_wipe_data = options.reindex || options.reindex_chainstate;
-
     auto& pblocktree{chainman.m_blockman.m_block_tree_db};
     // new CBlockTreeDB tries to delete the existing file, which
     // fails if it's still open from the previous loop. Close it first:
     pblocktree.reset();
     pblocktree.reset(new CBlockTreeDB(cache_sizes.block_tree_db, options.block_tree_db_in_memory, options.reindex));
 
-    // Initialize llmq_ctx
-    llmq_ctx.reset();
-    llmq_ctx = std::make_unique<LLMQContext>(dmnman, evodb, chainman,
-                                             util::DbWrapperParams{.path = options.data_dir, .memory = options.dash_dbs_in_memory, .wipe = to_wipe_data},
-                                             options.bls_threads, options.worker_count, options.max_recsigs_age);
-
-    // Initialize chain_helper
-    chain_helper.reset();
-    chain_helper = std::make_unique<CChainstateHelper>(evodb, dmnman, *options.mn_sync, *options.isman, *(llmq_ctx->quorum_block_processor),
-                                                       *(llmq_ctx->qsnapman), chainman, chainman.m_blockman, chainman.GetConsensus(),
-                                                       *options.chainlocks, *(llmq_ctx->qman));
-
     if (options.reindex) {
         pblocktree->WriteReindexing(true);
         //If we're reindexing in prune mode, wipe away unusable block files and all undo data files
@@ -278,7 +262,7 @@ static ChainstateLoadResult CompleteChainstateInitialization(ChainstateManager&
         }
     }
 
-    if (!chain_helper->ehf_manager->ForceSignalDBUpdate(chainman.ActiveTip())) {
+    if (!special_tx.m_mnhfman->ForceSignalDBUpdate(chainman.ActiveTip())) {
         return {ChainstateLoadStatus::FAILURE, _("Error upgrading evo database for EHF")};
     }
 
@@ -297,12 +281,9 @@ static ChainstateLoadResult CompleteChainstateInitialization(ChainstateManager&
 
 ChainstateLoadResult LoadChainstate(ChainstateManager& chainman, const CacheSizes& cache_sizes,
                                     const ChainstateLoadOptions& options, CEvoDB& evodb,
-                                    CDeterministicMNManager& dmnman, std::unique_ptr<LLMQContext>& llmq_ctx,
-                                    std::unique_ptr<CChainstateHelper>& chain_helper)
+                                    CDeterministicMNManager& dmnman, CSpecialTxProcessor& special_tx)
 {
-    assert(options.isman);
     assert(options.chainlocks);
-    assert(options.mn_sync);
 
     if (!chainman.AssumedValidBlock().IsNull()) {
         LogPrintf("Assuming ancestors of block %s have valid signatures.\n", chainman.AssumedValidBlock().GetHex());
@@ -331,7 +312,7 @@ ChainstateLoadResult LoadChainstate(ChainstateManager& chainman, const CacheSize
     chainman.m_total_coinsdb_cache = cache_sizes.coins_db;
 
     // Load the fully validated chainstate.
-    chainman.InitializeChainstate(options.mempool, evodb, chain_helper);
+    chainman.InitializeChainstate(options.mempool, evodb, special_tx, *options.chainlocks, options.isman);
 
     // On a reindex the caller hands us a freshly wiped EvoDB, without the
     // SNAPSHOT best-block marker that ActivateExistingSnapshot() requires, so a
@@ -350,7 +331,7 @@ ChainstateLoadResult LoadChainstate(ChainstateManager& chainman, const CacheSize
     }
 
     auto [init_status, init_error] = CompleteChainstateInitialization(chainman, cache_sizes, options, evodb, dmnman,
-                                                                      llmq_ctx, chain_helper);
+                                                                      special_tx);
     if (init_status != ChainstateLoadStatus::SUCCESS) {
         return {init_status, init_error};
     }
@@ -369,8 +350,6 @@ ChainstateLoadResult LoadChainstate(ChainstateManager& chainman, const CacheSize
         // Do nothing; expected case.
     } else if (snapshot_completion == SnapshotCompletionResult::SUCCESS) {
         LogPrintf("[snapshot] cleaning up unneeded background chainstate, then reinitializing\n");
-        chain_helper.reset();
-        llmq_ctx.reset();
         if (!chainman.ValidatedSnapshotCleanup()) {
             return {ChainstateLoadStatus::FAILURE_FATAL, Untranslated("Background chainstate cleanup failed unexpectedly.")};
         }
@@ -382,14 +361,14 @@ ChainstateLoadResult LoadChainstate(ChainstateManager& chainman, const CacheSize
         assert(!chainman.IsSnapshotActive());
         assert(!chainman.IsSnapshotValidated());
 
-        chainman.InitializeChainstate(options.mempool, evodb, chain_helper);
+        chainman.InitializeChainstate(options.mempool, evodb, special_tx, *options.chainlocks, options.isman);
 
         // A reload of the block index is required to recompute setBlockIndexCandidates
         // for the fully validated chainstate.
         chainman.ActiveChainstate().ClearBlockIndexCandidates();
 
         std::tie(init_status, init_error) = CompleteChainstateInitialization(chainman, cache_sizes, options, evodb,
-                                                                             dmnman, llmq_ctx, chain_helper);
+                                                                             dmnman, special_tx);
         if (init_status != ChainstateLoadStatus::SUCCESS) {
             return {init_status, init_error};
         }
diff --git a/src/node/chainstate.h b/src/node/chainstate.h
index 82909aca6237..1a5b63b03a28 100644
--- a/src/node/chainstate.h
+++ b/src/node/chainstate.h
@@ -5,7 +5,6 @@
 #ifndef BITCOIN_NODE_CHAINSTATE_H
 #define BITCOIN_NODE_CHAINSTATE_H
 
-#include <llmq/options.h>
 #include <util/fs.h>
 #include <validation.h>
 
@@ -16,13 +15,11 @@
 #include <string>
 #include <tuple>
 
-class CChainstateHelper;
 class CDeterministicMNManager;
 class CEvoDB;
 class ChainstateManager;
-class CMasternodeSync;
+class CSpecialTxProcessor;
 class CTxMemPool;
-struct LLMQContext;
 
 namespace chainlock { class Chainlocks; }
 namespace llmq { class CInstantSendManager; }
@@ -35,7 +32,6 @@ struct ChainstateLoadOptions {
     CTxMemPool* mempool{nullptr};
     llmq::CInstantSendManager* isman{nullptr};
     chainlock::Chainlocks* chainlocks{nullptr};
-    const CMasternodeSync* mn_sync{nullptr};
     fs::path data_dir;
 
     bool block_tree_db_in_memory{false};
@@ -44,9 +40,6 @@ struct ChainstateLoadOptions {
     bool reindex{false};
     bool reindex_chainstate{false};
     bool prune{false};
-    int8_t bls_threads{llmq::DEFAULT_BLSCHECK_THREADS};
-    int16_t worker_count{llmq::DEFAULT_WORKER_COUNT};
-    int64_t max_recsigs_age{llmq::DEFAULT_MAX_RECOVERED_SIGS_AGE};
     //! Setting require_full_verification to true will require all checks at
     //! check_level (below) to succeed for loading to succeed. Setting it to
     //! false will skip checks if cache is not big enough to run them, so may be
@@ -86,14 +79,10 @@ using ChainstateLoadResult = std::tuple<ChainstateLoadStatus, bilingual_str>;
  *    - a failure that definitively cannot be recovered from with a reindex
  *
  *  LoadChainstate returns a (status code, error string) tuple.
- *
- *  The llmq_ctx and chain_helper arguments are outputs: any instance they hold
- *  is destroyed and replaced with a freshly constructed one.
  */
 ChainstateLoadResult LoadChainstate(ChainstateManager& chainman, const CacheSizes& cache_sizes,
                                     const ChainstateLoadOptions& options, CEvoDB& evodb,
-                                    CDeterministicMNManager& dmnman, std::unique_ptr<LLMQContext>& llmq_ctx,
-                                    std::unique_ptr<CChainstateHelper>& chain_helper);
+                                    CDeterministicMNManager& dmnman, CSpecialTxProcessor& special_tx);
 ChainstateLoadResult VerifyLoadedChainstate(ChainstateManager& chainman, const ChainstateLoadOptions& options, CEvoDB& evodb,
                                             std::function<void(bool)> notify_bls_state = nullptr);
 } // namespace node
diff --git a/src/node/context.cpp b/src/node/context.cpp
index e5e07563dcdc..244e2ed94c22 100644
--- a/src/node/context.cpp
+++ b/src/node/context.cpp
@@ -26,12 +26,11 @@
 #include <coinjoin/coinjoin.h>
 #include <coinjoin/walletman.h>
 #include <dsnotificationinterface.h>
-#include <evo/chainhelper.h>
-#include <evo/creditpool.h>
 #include <evo/deterministicmns.h>
 #include <evo/evodb.h>
-#include <evo/mnhftx.h>
+#include <evo/specialtxman.h>
 #include <governance/governance.h>
+#include <governance/superblock.h>
 #include <instantsend/instantsend.h>
 #include <interfaces/coinjoin.h>
 #include <llmq/context.h>
diff --git a/src/node/context.h b/src/node/context.h
index 56f80d825161..ddda10a4f60e 100644
--- a/src/node/context.h
+++ b/src/node/context.h
@@ -17,14 +17,12 @@
 class AddressIndex;
 class ArgsManager;
 class BanMan;
-class CActiveMasternodeManager;
 class AddrMan;
 class CBlockPolicyEstimator;
 class CConnman;
 class CDeterministicMNManager;
 class CDSNotificationInterface;
 class CDSTXManager;
-class CChainstateHelper;
 class ChainstateManager;
 class CEvoDB;
 class CGovernanceManager;
@@ -33,6 +31,7 @@ class CMasternodeMetaMan;
 class CMasternodeSync;
 class CNetFulfilledRequestManager;
 class CScheduler;
+class CSpecialTxProcessor;
 class CSporkManager;
 class CTxMemPool;
 class NetGroupManager;
@@ -47,6 +46,10 @@ class Chainlocks;
 class ChainlockHandler;
 } // namespace chainlock
 
+namespace governance {
+class SuperblockManager;
+} // namespace governance
+
 namespace interfaces {
 class Chain;
 class ChainClient;
@@ -101,13 +104,14 @@ struct NodeContext {
     std::unique_ptr<CJWalletManager> cj_walletman;
     std::unique_ptr<CDSTXManager> dstxman;
     std::unique_ptr<CEvoDB> evodb;
-    std::unique_ptr<CChainstateHelper> chain_helper;
+    std::unique_ptr<CSpecialTxProcessor> special_tx;
     std::unique_ptr<CDeterministicMNManager> dmnman;
     std::unique_ptr<llmq::CInstantSendManager> isman;
     std::unique_ptr<CGovernanceManager> govman;
     std::unique_ptr<CMasternodeMetaMan> mn_metaman;
     std::unique_ptr<CMasternodeSync> mn_sync;
     std::unique_ptr<CNetFulfilledRequestManager> netfulfilledman;
+    std::unique_ptr<governance::SuperblockManager> sbman;
     std::unique_ptr<CSporkManager> sporkman;
     std::unique_ptr<chainlock::Chainlocks> chainlocks;
     std::unique_ptr<chainlock::ChainlockHandler> clhandler;
diff --git a/src/node/interfaces.cpp b/src/node/interfaces.cpp
index fce39a312367..e0f5e1095770 100644
--- a/src/node/interfaces.cpp
+++ b/src/node/interfaces.cpp
@@ -12,7 +12,6 @@
 #include <chainparams.h>
 #include <coinjoin/common.h>
 #include <deploymentstatus.h>
-#include <evo/chainhelper.h>
 #include <evo/creditpool.h>
 #include <evo/deterministicmns.h>
 #include <evo/providertx_service.h>
@@ -430,7 +429,7 @@ class GOVImpl : public GOV
             const Consensus::Params& consensusParams = context().chainman->GetConsensus();
             LOCK(::cs_main);
             CSuperblock::GetNearestSuperblocksHeights(context().chainman->ActiveHeight(), info.lastsuperblock, info.nextsuperblock);
-            info.governancebudget = CSuperblock::GetPaymentsLimit(context().chainman->ActiveChain(), info.nextsuperblock);
+            info.governancebudget = CSuperblock::GetPaymentsLimit(info.nextsuperblock);
             if (context().dmnman) {
                 info.fundingthreshold = static_cast<int>(context().dmnman->GetListAtChainTip().GetCounts().m_valid_weighted / 10);
             }
@@ -445,9 +444,9 @@ class GOVImpl : public GOV
     }
     std::optional<int32_t> getProposalFundedHeight(const uint256& proposal_hash) override
     {
-        if (context().chain_helper != nullptr && context().chainman != nullptr) {
+        if (context().sbman != nullptr && context().chainman != nullptr) {
             const int32_t nTipHeight = WITH_LOCK(::cs_main, return context().chainman->ActiveHeight());
-            for (const auto& trigger : context().chain_helper->superblocks->GetActiveTriggers()) {
+            for (const auto& trigger : context().sbman->GetActiveTriggers()) {
                 if (!trigger || trigger->GetBlockHeight() > nTipHeight) continue;
                 for (const auto& hash : trigger->GetProposalHashes()) {
                     if (hash == proposal_hash) {
@@ -469,7 +468,7 @@ class GOVImpl : public GOV
                 {
                     LOCK(::cs_main);
                     CSuperblock::GetNearestSuperblocksHeights(context().chainman->ActiveHeight(), last_sb, next_sb);
-                    budget = CSuperblock::GetPaymentsLimit(context().chainman->ActiveChain(), next_sb);
+                    budget = CSuperblock::GetPaymentsLimit(next_sb);
                 }
                 for (const auto& proposal : proposals) {
                     UniValue json = proposal->GetJSONObject();
@@ -566,18 +565,18 @@ class LLMQImpl : public LLMQ
     CreditPoolCounts getCreditPoolCounts() override
     {
         CreditPoolCounts ret{};
-        if (!context().chainman) {
+        if (!context().chainman || !context().special_tx) {
             return ret;
         }
         const auto* pindex{WITH_LOCK(::cs_main, return context().chainman->ActiveChain().Tip())};
         if (!pindex || !pindex->pprev) {
             return ret;
         }
-        auto& chain_helper{context().chainman->ActiveChainstate().ChainHelper()};
-        const auto pool{chain_helper.GetCreditPool(pindex)};
+        auto& cpoolman{*context().special_tx->m_cpoolman};
+        const auto pool{cpoolman.GetCreditPool(pindex)};
         ret.m_locked = pool.locked;
         ret.m_limit = pool.currentLimit;
-        ret.m_diff = pool.locked - chain_helper.GetCreditPool(pindex->pprev).locked;
+        ret.m_diff = pool.locked - cpoolman.GetCreditPool(pindex->pprev).locked;
         return ret;
     }
     ChainLockInfo getBestChainLock() override
diff --git a/src/node/miner.cpp b/src/node/miner.cpp
index 7009839ab8bc..b3a32bad66d3 100644
--- a/src/node/miner.cpp
+++ b/src/node/miner.cpp
@@ -28,13 +28,12 @@
 #include <chainlock/handler.h>
 #include <evo/specialtx.h>
 #include <evo/cbtx.h>
-#include <evo/chainhelper.h>
 #include <evo/creditpool.h>
 #include <evo/mnhftx.h>
 #include <evo/deterministicmns.h>
 #include <evo/simplifiedmns.h>
 #include <evo/specialtxman.h>
-#include <governance/governance.h>
+#include <instantsend/instantsend.h>
 #include <llmq/blockprocessor.h>
 #include <llmq/context.h>
 #include <llmq/options.h>
@@ -69,9 +68,9 @@ static BlockAssembler::Options ClampOptions(BlockAssembler::Options options)
 }
 
 BlockAssembler::BlockAssembler(Chainstate& chainstate, const NodeContext& node, const CTxMemPool* mempool, const Options& options) :
-      m_chain_helper(chainstate.ChainHelper()),
       m_chainstate{chainstate},
       m_evoDb(*Assert(node.evodb)),
+      m_dmnman(*Assert(node.dmnman)),
       m_chainlocks(*Assert(node.chainlocks)),
       m_clhandler(*Assert(node.clhandler)),
       chainparams(chainstate.m_chainman.GetParams()),
@@ -172,6 +171,51 @@ static bool CalcCbTxBestChainlock(const chainlock::Chainlocks& chainlocks, const
 }
 
 
+void BlockAssembler::FillBlockPayments(CMutableTransaction& txNew, const CBlockIndex* pindexPrev, const CAmount blockSubsidy, const CAmount feeReward)
+{
+    int nBlockHeight = pindexPrev == nullptr ? 0 : pindexPrev->nHeight + 1;
+    const auto mn_list{m_dmnman.GetListForBlock(pindexPrev)};
+    std::vector<CTxOut>& voutMasternodePaymentsRet{pblocktemplate->voutMasternodePayments};
+    std::vector<CTxOut>& voutSuperblockPaymentsRet{pblocktemplate->voutSuperblockPayments};
+
+    // Only create superblocks when one is actually triggered.
+    if (const auto& superblock_status{m_chainstate.m_chainman.m_options.superblock_status}) {
+        SuperblockStatus superblock{superblock_status(mn_list, nBlockHeight)};
+        if (superblock.state == SuperblockStatus::State::Triggered) {
+            LogPrint(BCLog::GOBJECT, "%s -- Triggered superblock creation at height %d\n", __func__, nBlockHeight);
+            voutSuperblockPaymentsRet = std::move(superblock.payments);
+        }
+    }
+
+    const MnRewardEra era{GetMnRewardEraAfter(pindexPrev, m_chainstate.m_chainman)};
+    if (!GetMasternodePayments(mn_list, pindexPrev, blockSubsidy, feeReward, era, chainparams.GetConsensus(), voutMasternodePaymentsRet)) {
+        LogPrintf("%s -- ERROR Failed to get payee\n", __func__);
+        LogPrint(BCLog::MNPAYMENTS, "%s -- No masternode to pay (MN list probably empty)\n", __func__);
+    } else {
+        for (const auto& txout : voutMasternodePaymentsRet) {
+            CTxDestination dest;
+            ExtractDestination(txout.scriptPubKey, dest);
+
+            LogPrintf("%s -- Masternode payment %lld to %s\n", __func__, txout.nValue, EncodeDestination(dest));
+        }
+    }
+
+    txNew.vout.insert(txNew.vout.end(), voutMasternodePaymentsRet.begin(), voutMasternodePaymentsRet.end());
+    txNew.vout.insert(txNew.vout.end(), voutSuperblockPaymentsRet.begin(), voutSuperblockPaymentsRet.end());
+
+    std::string voutMasternodeStr;
+    for (const auto& txout : voutMasternodePaymentsRet) {
+        // subtract MN payment from miner reward
+        txNew.vout[0].nValue -= txout.nValue;
+        if (!voutMasternodeStr.empty())
+            voutMasternodeStr += ",";
+        voutMasternodeStr += txout.ToString();
+    }
+
+    LogPrint(BCLog::MNPAYMENTS, "%s -- nBlockHeight %d blockReward %lld voutMasternodePaymentsRet \"%s\" txNew %s", __func__, /* Continued */
+                            nBlockHeight, blockSubsidy + feeReward, voutMasternodeStr, txNew.ToString());
+}
+
 std::unique_ptr<CBlockTemplate> BlockAssembler::CreateNewBlock(const CScript& scriptPubKeyIn)
 {
     const auto time_start{SteadyClock::now()};
@@ -284,7 +328,7 @@ std::unique_ptr<CBlockTemplate> BlockAssembler::CreateNewBlock(const CScript& sc
         BlockValidationState state;
         CDeterministicMNList mn_list;
         const bool is_v24_active{DeploymentActiveAfter(pindexPrev, m_chainstate.m_chainman, Consensus::DEPLOYMENT_V24)};
-        if (!m_chain_helper.special_tx->BuildNewListFromBlock(*pblock, pindexPrev, is_v24_active,
+        if (!m_chainstate.m_special_tx.BuildNewListFromBlock(*pblock, pindexPrev, is_v24_active,
                                                               m_chainstate.CoinsTip(), true, state, mn_list)) {
             throw std::runtime_error(strprintf("%s: BuildNewListFromBlock failed: %s", __func__, state.ToString()));
         }
@@ -303,7 +347,7 @@ std::unique_ptr<CBlockTemplate> BlockAssembler::CreateNewBlock(const CScript& sc
                     LogPrintf("CreateNewBlock() h[%d] CbTx failed to find best CL. Inserting null CL\n", nHeight);
                 }
                 BlockValidationState state;
-                const auto creditPoolDiff = GetCreditPoolDiffForBlock(*m_chain_helper.credit_pool_manager, *pblock, pindexPrev, chainparams.GetConsensus(), blockSubsidy, state);
+                const auto creditPoolDiff = GetCreditPoolDiffForBlock(*m_chainstate.m_special_tx.m_cpoolman, *pblock, pindexPrev, chainparams.GetConsensus(), blockSubsidy, state);
                 if (creditPoolDiff == std::nullopt) {
                     throw std::runtime_error(strprintf("%s: GetCreditPoolDiffForBlock failed: %s", __func__, state.ToString()));
                 }
@@ -321,8 +365,7 @@ std::unique_ptr<CBlockTemplate> BlockAssembler::CreateNewBlock(const CScript& sc
 
     // Update coinbase transaction with additional info about masternode and governance payments,
     // get some info back to pass to getblocktemplate
-    const MnRewardEra mn_reward_era{GetMnRewardEraAfter(pindexPrev, m_chainstate.m_chainman)};
-    m_chain_helper.mn_payments->FillBlockPayments(coinbaseTx, pindexPrev, blockSubsidy, nFees, mn_reward_era, pblocktemplate->voutMasternodePayments, pblocktemplate->voutSuperblockPayments);
+    FillBlockPayments(coinbaseTx, pindexPrev, blockSubsidy, nFees);
 
     pblock->vtx[0] = MakeTransactionRef(std::move(coinbaseTx));
     pblocktemplate->vTxFees[0] = -nFees;
@@ -395,7 +438,7 @@ bool BlockAssembler::TestPackageTransactions(const CTxMemPool::setEntries& packa
         // signature regardless, which is cheap enough here given how rare MNHF signals are.
         if (it->GetTx().IsSpecialTxVersion()) {
             TxValidationState tx_state;
-            if (!m_chain_helper.special_tx->CheckSpecialTx(it->GetTx(), m_chainstate.m_chain.Tip(), special_tx_rules,
+            if (!m_chainstate.m_special_tx.CheckSpecialTx(it->GetTx(), m_chainstate.m_chain.Tip(), special_tx_rules,
                                                            m_chainstate.CoinsTip(), /*check_sigs=*/false, tx_state)) {
                 return false;
             }
@@ -414,7 +457,7 @@ bool BlockAssembler::TestPackageTransactions(const CTxMemPool::setEntries& packa
         }
 
         const auto& txid = it->GetTx().GetHash();
-        if (!m_chain_helper.IsInstantSendEnabled() || m_chain_helper.IsInstantSendLocked(txid)) {
+        if (auto* isman{m_chainstate.m_isman}; isman == nullptr || !isman->IsInstantSendEnabled() || isman->IsLocked(txid)) {
             continue;
         }
 
@@ -503,12 +546,12 @@ void BlockAssembler::addPackageTxs(const CTxMemPool& mempool, int& nPackagesSele
     // duplicates of indexes. There's used `BlockSubsidy` equaled to 0
     std::optional<CCreditPoolDiff> creditPoolDiff;
     if (DeploymentActiveAfter(pindexPrev, chainparams.GetConsensus(), Consensus::DEPLOYMENT_V20)) {
-        CCreditPool creditPool = m_chain_helper.GetCreditPool(pindexPrev);
+        CCreditPool creditPool = m_chainstate.m_special_tx.m_cpoolman->GetCreditPool(pindexPrev);
         creditPoolDiff.emplace(std::move(creditPool), pindexPrev, chainparams.GetConsensus(), 0);
     }
 
     // This map with signals is used only to find duplicates
-    auto signals = m_chain_helper.ehf_manager->GetSignalsStage(pindexPrev);
+    auto signals = m_chainstate.m_special_tx.m_mnhfman->GetSignalsStage(pindexPrev);
     const SpecialTxRules special_tx_rules{GetSpecialTxRules(pindexPrev, m_chainstate.m_chainman)};
 
     // mapModifiedTx will store sorted packages after they are modified
@@ -649,7 +692,7 @@ void BlockAssembler::addPackageTxs(const CTxMemPool& mempool, int& nPackagesSele
                 // producing an invalid template.
                 if (IsAssetUnlockWithStableTxid(tx)) {
                     TxValidationState state;
-                    if (!m_chain_helper.special_tx->CheckSpecialTx(tx, m_chainstate.m_chain.Tip(), special_tx_rules,
+                    if (!m_chainstate.m_special_tx.CheckSpecialTx(tx, m_chainstate.m_chain.Tip(), special_tx_rules,
                                                                    m_chainstate.CoinsTip(), /*check_sigs=*/true, state)) {
                         LogPrintf("%s: package tx %s skipped, asset unlock instance not currently minable: %s\n", __func__,
                                   tx.GetHash().ToString(), state.ToString());
diff --git a/src/node/miner.h b/src/node/miner.h
index 18d27b8e834a..ef7a6906efc1 100644
--- a/src/node/miner.h
+++ b/src/node/miner.h
@@ -23,11 +23,9 @@
 class ArgsManager;
 class CBlockIndex;
 class CChainParams;
-class CChainstateHelper;
-class CConnman;
+class CDeterministicMNManager;
 class CEvoDB;
 class CScript;
-struct LLMQContext;
 
 namespace chainlock
 {
@@ -162,9 +160,9 @@ class BlockAssembler
     int nHeight;
     int64_t m_lock_time_cutoff;
 
-    CChainstateHelper& m_chain_helper;
     Chainstate& m_chainstate;
     CEvoDB& m_evoDb;
+    CDeterministicMNManager& m_dmnman;
     const chainlock::Chainlocks& m_chainlocks;
     chainlock::ChainlockHandler& m_clhandler;
     const CChainParams& chainparams;
@@ -198,6 +196,10 @@ class BlockAssembler
     void resetBlock();
     /** Add a tx to the block */
     void AddToBlock(CTxMemPool::txiter iter);
+    /** Append the masternode payments and, when a superblock is triggered,
+     *  the superblock payments to the coinbase. */
+    void FillBlockPayments(CMutableTransaction& txNew, const CBlockIndex* pindexPrev, CAmount blockSubsidy,
+                           CAmount feeReward) EXCLUSIVE_LOCKS_REQUIRED(::cs_main);
 
     // Methods for how to add transactions to a block.
     /** Add transactions based on feerate including unconfirmed ancestors
diff --git a/src/rpc/blockchain.cpp b/src/rpc/blockchain.cpp
index e09dc384984c..3feb2541048b 100644
--- a/src/rpc/blockchain.cpp
+++ b/src/rpc/blockchain.cpp
@@ -16,7 +16,6 @@
 #include <consensus/validation.h>
 #include <deploymentinfo.h>
 #include <deploymentstatus.h>
-#include <evo/chainhelper.h>
 #include <index/blockfilterindex.h>
 #include <index/coinstatsindex.h>
 #include <index/spentindex.h>
@@ -57,6 +56,7 @@
 #include <evo/creditpool.h>
 #include <evo/evodb.h>
 #include <evo/mnhftx.h>
+#include <evo/specialtxman.h>
 #include <evo/specialtx.h>
 #include <evo/specialtx_filter.h>
 #include <instantsend/instantsend.h>
@@ -1624,7 +1624,7 @@ RPCHelpMan getblockchaininfo()
     }
 
     if (IsDeprecatedRPCEnabled("softforks")) {
-        const auto ehf_signals{active_chainstate.ChainHelper().GetSignalsStage(&tip)};
+        const auto ehf_signals{CHECK_NONFATAL(node.special_tx)->m_mnhfman->GetSignalsStage(&tip)};
         obj.pushKV("softforks", DeploymentInfo(&tip, ehf_signals, chainman));
     }
 
@@ -1732,7 +1732,7 @@ RPCHelpMan getdeploymentinfo()
                 }
             }
 
-            const auto ehf_signals{active_chainstate.ChainHelper().GetSignalsStage(blockindex)};
+            const auto ehf_signals{CHECK_NONFATAL(node.special_tx)->m_mnhfman->GetSignalsStage(blockindex)};
 
             UniValue deploymentinfo(UniValue::VOBJ);
             deploymentinfo.pushKV("hash", blockindex->GetBlockHash().ToString());
@@ -1792,7 +1792,7 @@ static RPCHelpMan getcreditpoolinfo()
 {
     const NodeContext& node = EnsureAnyNodeContext(request.context);
     ChainstateManager& chainman = EnsureChainman(node);
-    auto& chain_helper = chainman.ActiveChainstate().ChainHelper();
+    CCreditPoolManager& cpoolman = *CHECK_NONFATAL(node.special_tx)->m_cpoolman;
 
     const CBlockIndex* pindex{WITH_LOCK(::cs_main, return request.params[0].isNull()
                                                        ? chainman.ActiveChain().Tip()
@@ -1805,7 +1805,7 @@ static RPCHelpMan getcreditpoolinfo()
     // nullptr when the chain is shorter than the window
     const CBlockIndex* pindex_window_start{pindex->GetAncestor(pindex->nHeight - window_blocks)};
 
-    const CCreditPool pool{chain_helper.GetCreditPool(pindex)};
+    const CCreditPool pool{cpoolman.GetCreditPool(pindex)};
     // The same read the consensus rule makes for the window start
     const CAmount window_start_balance{
         pindex_window_start ? CCreditPoolManager::GetBalanceAt(pindex_window_start, chainman.GetConsensus()) : CAmount{0}};
diff --git a/src/rpc/evo.cpp b/src/rpc/evo.cpp
index 8db3f4f93e89..5268ec088b51 100644
--- a/src/rpc/evo.cpp
+++ b/src/rpc/evo.cpp
@@ -7,7 +7,6 @@
 #include <consensus/validation.h>
 #include <core_io.h>
 #include <deploymentstatus.h>
-#include <evo/chainhelper.h>
 #include <evo/deterministicmns.h>
 #include <evo/dmn_types.h>
 #include <evo/providertx.h>
@@ -1986,7 +1985,7 @@ static UniValue evodb_verify_or_repair_impl(const JSONRPCRequest& request, bool
     const NodeContext& node = EnsureAnyNodeContext(request.context);
     ChainstateManager& chainman = EnsureChainman(node);
     CDeterministicMNManager& dmnman = *CHECK_NONFATAL(node.dmnman);
-    CChainstateHelper& chain_helper = *CHECK_NONFATAL(node.chain_helper);
+    CSpecialTxProcessor& special_tx = *CHECK_NONFATAL(node.special_tx);
 
     const CBlockIndex* start_index;
     const CBlockIndex* stop_index;
@@ -2032,12 +2031,12 @@ static UniValue evodb_verify_or_repair_impl(const JSONRPCRequest& request, bool
     }
 
     // Create a callback that wraps CSpecialTxProcessor::RebuildListFromBlock
-    auto build_list_func = [&chain_helper, &chainman](const CBlock& block, const CBlockIndex* const pindexPrev,
+    auto build_list_func = [&special_tx, &chainman](const CBlock& block, const CBlockIndex* const pindexPrev,
                                                       const CDeterministicMNList& prevList, const CCoinsViewCache& view,
                                                       bool debugLogs, BlockValidationState& state,
                                                       CDeterministicMNList& mnListRet) -> bool {
         const bool is_v24_active{DeploymentActiveAfter(pindexPrev, chainman, Consensus::DEPLOYMENT_V24)};
-        return chain_helper.special_tx->RebuildListFromBlock(block, pindexPrev, is_v24_active, prevList, view,
+        return special_tx.RebuildListFromBlock(block, pindexPrev, is_v24_active, prevList, view,
                                                              debugLogs, state, mnListRet);
     };
 
diff --git a/src/rpc/governance.cpp b/src/rpc/governance.cpp
index 7f3ed99c2010..17145823471b 100644
--- a/src/rpc/governance.cpp
+++ b/src/rpc/governance.cpp
@@ -983,7 +983,7 @@ static RPCHelpMan getgovernanceinfo()
     obj.pushKV("lastsuperblock", nLastSuperblock);
     obj.pushKV("nextsuperblock", nNextSuperblock);
     obj.pushKV("fundingthreshold", CHECK_NONFATAL(node.dmnman)->GetListAtChainTip().GetCounts().m_valid_weighted / 10);
-    obj.pushKV("governancebudget", ValueFromAmount(WITH_LOCK(::cs_main, return CSuperblock::GetPaymentsLimit(chainman.ActiveChain(), nNextSuperblock))));
+    obj.pushKV("governancebudget", ValueFromAmount(CSuperblock::GetPaymentsLimit(nNextSuperblock)));
 
     return obj;
 },
@@ -1011,8 +1011,7 @@ static RPCHelpMan getsuperblockbudget()
         throw JSONRPCError(RPC_INVALID_PARAMETER, "Block height out of range");
     }
 
-    const ChainstateManager& chainman = EnsureAnyChainman(request.context);
-    return ValueFromAmount(WITH_LOCK(::cs_main, return CSuperblock::GetPaymentsLimit(chainman.ActiveChain(), nBlockHeight)));
+    return ValueFromAmount(CSuperblock::GetPaymentsLimit(nBlockHeight));
 },
     };
 }
diff --git a/src/rpc/masternode.cpp b/src/rpc/masternode.cpp
index dce33a47300a..6ae16e7f2cd4 100644
--- a/src/rpc/masternode.cpp
+++ b/src/rpc/masternode.cpp
@@ -5,7 +5,6 @@
 #include <active/context.h>
 #include <active/masternode.h>
 #include <evo/assetlocktx.h>
-#include <evo/chainhelper.h>
 #include <evo/deterministicmns.h>
 #include <governance/superblock.h>
 #include <masternode/payments.h>
@@ -249,13 +248,9 @@ static std::string GetRequiredPaymentsString(governance::SuperblockManager& supe
             strPayments += ", " + EncodeDestination(dest);
         }
     }
-    if (superblocks.IsSuperblockTriggered(tip_mn_list, nBlockHeight)) {
-        std::vector<CTxOut> voutSuperblock;
-        if (!superblocks.GetSuperblockPayments(tip_mn_list, nBlockHeight, voutSuperblock)) {
-            return strPayments + ", error";
-        }
+    if (const SuperblockStatus superblock{superblocks.GetStatus(tip_mn_list, nBlockHeight)}; superblock.state == SuperblockStatus::State::Triggered) {
         std::string strSBPayees = "Unknown";
-        for (const auto& txout : voutSuperblock) {
+        for (const auto& txout : superblock.payments) {
             CTxDestination dest;
             ExtractDestination(txout.scriptPubKey, dest);
             if (strSBPayees != "Unknown") {
@@ -330,7 +325,7 @@ static RPCHelpMan masternode_winners()
         const CBlockIndex* pIndex = pindexTip->GetAncestor(h - 1);
         auto payee = node.dmnman->GetListForBlock(pIndex).GetMNPayee(pIndex);
         if (payee) {
-            std::string strPayments = GetRequiredPaymentsString(*CHECK_NONFATAL(node.chain_helper)->superblocks,
+            std::string strPayments = GetRequiredPaymentsString(*CHECK_NONFATAL(node.sbman),
                                                                 tip_mn_list, h, payee);
             if (!strFilter.empty() && strPayments.find(strFilter) == std::string::npos) continue;
             obj.pushKV(strprintf("%d", h), strPayments);
@@ -340,7 +335,7 @@ static RPCHelpMan masternode_winners()
     auto projection = node.dmnman->GetListForBlock(pindexTip).GetProjectedMNPayees(pindexTip, /*nCount=*/20);
     for (size_t i = 0; i < projection.size(); i++) {
         int h = nChainTipHeight + 1 + i;
-        std::string strPayments = GetRequiredPaymentsString(*node.chain_helper->superblocks, tip_mn_list, h, projection[i]);
+        std::string strPayments = GetRequiredPaymentsString(*node.sbman, tip_mn_list, h, projection[i]);
         if (!strFilter.empty() && strPayments.find(strFilter) == std::string::npos) continue;
         obj.pushKV(strprintf("%d", h), strPayments);
     }
@@ -415,7 +410,6 @@ static RPCHelpMan masternode_payments()
     // A temporary vector which is used to sort results properly (there is no "reverse" in/for UniValue)
     std::vector<UniValue> vecPayments;
 
-    CHECK_NONFATAL(node.chain_helper);
     CHECK_NONFATAL(node.dmnman);
     while (vecPayments.size() < uint64_t(std::abs(nCount)) && pindex != nullptr) {
         CBlock block;
@@ -447,11 +441,13 @@ static RPCHelpMan masternode_payments()
             nBlockFees += nValueIn - tx->GetValueOut();
         }
 
-        std::vector<CTxOut> voutMasternodePayments, voutDummy;
-        CMutableTransaction dummyTx;
+        std::vector<CTxOut> voutMasternodePayments;
         CAmount blockSubsidy = GetBlockSubsidy(pindex, Params().GetConsensus());
         const MnRewardEra mn_reward_era{GetMnRewardEraAfter(pindex->pprev, chainman)};
-        node.chain_helper->mn_payments->FillBlockPayments(dummyTx, pindex->pprev, blockSubsidy, nBlockFees, mn_reward_era, voutMasternodePayments, voutDummy);
+        if (!GetMasternodePayments(node.dmnman->GetListForBlock(pindex->pprev), pindex->pprev, blockSubsidy, nBlockFees,
+                                   mn_reward_era, Params().GetConsensus(), voutMasternodePayments)) {
+            LogPrint(BCLog::MNPAYMENTS, "%s -- No masternode to pay (MN list probably empty)\n", __func__);
+        }
 
         UniValue blockObj(UniValue::VOBJ);
         CAmount payedPerBlock{0};
diff --git a/src/rpc/rawtransaction.cpp b/src/rpc/rawtransaction.cpp
index 17d83fbc2bdc..9b7b38e5269c 100644
--- a/src/rpc/rawtransaction.cpp
+++ b/src/rpc/rawtransaction.cpp
@@ -50,9 +50,9 @@
 #include <chainlock/chainlock.h>
 #include <evo/assetlocktx.h>
 #include <evo/cbtx.h>
-#include <evo/chainhelper.h>
 #include <evo/creditpool.h>
 #include <evo/mnhftx.h>
+#include <evo/specialtxman.h>
 #include <evo/providertx.h>
 #include <evo/specialtx.h>
 #include <instantsend/instantsend.h>
@@ -813,7 +813,7 @@ static RPCHelpMan getassetunlockstatuses()
     CHECK_NONFATAL(node.chainlocks);
     const ChainstateManager& chainman = EnsureChainman(node);
     const llmq::CInstantSendManager& isman = EnsureInstantSendManager(node);
-    auto& chain_helper = chainman.ActiveChainstate().ChainHelper();
+    CCreditPoolManager& cpoolman = *CHECK_NONFATAL(node.special_tx)->m_cpoolman;
     UniValue result_arr(UniValue::VARR);
     const UniValue str_indexes = request.params[0].get_array();
     if (str_indexes.size() > 100) {
@@ -845,7 +845,7 @@ static RPCHelpMan getassetunlockstatuses()
             pBlockIndex = chainman.ActiveChain()[nSpecificCoreHeight.value()];
         }
         CHECK_NONFATAL(pBlockIndex);
-        poolCL = std::make_optional(chain_helper.GetCreditPool(pBlockIndex));
+        poolCL = std::make_optional(cpoolman.GetCreditPool(pBlockIndex));
     }
     else {
         const auto pBlockIndexBestCL = [&]() -> const CBlockIndex* {
@@ -864,12 +864,12 @@ static RPCHelpMan getassetunlockstatuses()
         // We need in 2 credit pools: at tip of chain and on best CL to know if tx is mined or chainlocked
         // Sometimes that's two different blocks, sometimes not and we need to initialize 2nd creditPoolManager
         poolCL = pBlockIndexBestCL ?
-                 std::make_optional(chain_helper.GetCreditPool(pBlockIndexBestCL)) :
+                 std::make_optional(cpoolman.GetCreditPool(pBlockIndexBestCL)) :
                  std::nullopt;
 
         poolOnTip = [&]() -> std::optional<CCreditPool> {
             if (pTipBlockIndex != pBlockIndexBestCL) {
-                return std::make_optional(chain_helper.GetCreditPool(pTipBlockIndex));
+                return std::make_optional(cpoolman.GetCreditPool(pTipBlockIndex));
             }
             return std::nullopt;
         }();
diff --git a/src/test/coinjoin_inouts_tests.cpp b/src/test/coinjoin_inouts_tests.cpp
index 9bf2f803869b..0bbd76b6a793 100644
--- a/src/test/coinjoin_inouts_tests.cpp
+++ b/src/test/coinjoin_inouts_tests.cpp
@@ -10,7 +10,6 @@
 #include <coinjoin/common.h>
 #include <coinjoin/options.h>
 #include <coinjoin/server.h>
-#include <evo/chainhelper.h>
 #include <llmq/context.h>
 #include <masternode/sync.h>
 #include <net.h>
diff --git a/src/test/evo_assetlocks_tests.cpp b/src/test/evo_assetlocks_tests.cpp
index f9ac499106be..028697e65564 100644
--- a/src/test/evo_assetlocks_tests.cpp
+++ b/src/test/evo_assetlocks_tests.cpp
@@ -9,8 +9,8 @@
 #include <consensus/validation.h>
 #include <evo/assetlocktx.h>
 #include <evo/cbtx.h>
-#include <evo/chainhelper.h>
 #include <evo/creditpool.h>
+#include <evo/specialtxman.h>
 #include <evo/evodb.h>
 #include <evo/specialtx.h>
 #include <llmq/context.h>
@@ -840,7 +840,7 @@ BOOST_FIXTURE_TEST_CASE(credit_pool_snapshot_persisted_after_transactionless_con
     CreateAndProcessBlock({}, coinbase_pk);
     CCreditPool snapshot;
     BOOST_REQUIRE(m_node.evodb->Read(snapshot_key, snapshot));
-    const CCreditPool pool = m_node.chain_helper->credit_pool_manager->GetCreditPool(snapshot_index);
+    const CCreditPool pool = m_node.special_tx->m_cpoolman->GetCreditPool(snapshot_index);
     BOOST_CHECK_EQUAL(snapshot.locked, pool.locked);
     BOOST_CHECK_EQUAL(snapshot.currentLimit, pool.currentLimit);
 }
diff --git a/src/test/evo_deterministicmns_tests.cpp b/src/test/evo_deterministicmns_tests.cpp
index 42e084860296..4d43f7edd581 100644
--- a/src/test/evo_deterministicmns_tests.cpp
+++ b/src/test/evo_deterministicmns_tests.cpp
@@ -10,7 +10,6 @@
 #include <consensus/merkle.h>
 #include <consensus/validation.h>
 #include <deploymentstatus.h>
-#include <evo/chainhelper.h>
 #include <evo/deterministicmns.h>
 #include <evo/providertx.h>
 #include <evo/sharedcollateral.h>
@@ -1242,7 +1241,7 @@ void FuncProUpServInvalidNType(TestChainSetup& setup)
         BlockValidationState state;
         CDeterministicMNList mn_list;
         LOCK(cs_main);
-        BOOST_CHECK(!chainman.ActiveChainstate().ChainHelper().special_tx->BuildNewListFromBlock(
+        BOOST_CHECK(!chainman.ActiveChainstate().m_special_tx.BuildNewListFromBlock(
             block, tip_index(), IsV24Active(chainman), chainman.ActiveChainstate().CoinsTip(), /*debugLogs=*/false,
             state, mn_list));
         BOOST_CHECK_EQUAL(state.GetRejectReason(), expected_reason);
@@ -1512,7 +1511,7 @@ void FuncTestMempoolProRegReplacementUpdateConflict(TestChainSetup& setup)
 
         BlockValidationState state;
         CDeterministicMNList mn_list;
-        BOOST_CHECK(!chainman.ActiveChainstate().ChainHelper().special_tx->BuildNewListFromBlock(
+        BOOST_CHECK(!chainman.ActiveChainstate().m_special_tx.BuildNewListFromBlock(
             hazard_block, tip_index(), IsV24Active(chainman), chainman.ActiveChainstate().CoinsTip(),
             /*debugLogs=*/false, state, mn_list));
         BOOST_CHECK_EQUAL(state.GetRejectReason(), "bad-protx-hash");
@@ -2615,9 +2614,9 @@ void FuncSameMnSameBlockVersionCrossingKeyRotation(TestChainV24SignalBeforeV19Se
     std::string thrown;
     {
         LOCK(cs_main);
-        auto& chain_helper = *Assert(setup.m_node.chain_helper.get());
+        auto& special_tx = *Assert(setup.m_node.special_tx.get());
         try {
-            rebuilt = chain_helper.special_tx->RebuildListFromBlock(
+            rebuilt = special_tx.RebuildListFromBlock(
                 block, chainman.ActiveChain().Tip(), IsV24Active(chainman), dmnman.GetListAtChainTip(),
                 chainman.ActiveChainstate().CoinsTip(), /*debugLogs=*/false, block_state, mn_list_ret);
         } catch (const std::exception& e) {
@@ -2724,9 +2723,9 @@ void FuncSameMnSameBlockMigrationConsistent(TestChainV24SignalBeforeV19Setup& se
     bool rebuilt{false};
     {
         LOCK(cs_main);
-        auto& chain_helper = *Assert(setup.m_node.chain_helper.get());
+        auto& special_tx = *Assert(setup.m_node.special_tx.get());
         BOOST_CHECK_NO_THROW(
-            rebuilt = chain_helper.special_tx->RebuildListFromBlock(
+            rebuilt = special_tx.RebuildListFromBlock(
                 block, chainman.ActiveChain().Tip(), IsV24Active(chainman), dmnman.GetListAtChainTip(),
                 chainman.ActiveChainstate().CoinsTip(), /*debugLogs=*/false, block_state, mn_list_ret));
     }
@@ -2931,9 +2930,9 @@ void FuncSameBlockCrossSchemeKeyPairRejected(TestChainV24SignalBeforeV19Setup& s
     bool rebuilt{true};
     {
         LOCK(cs_main);
-        auto& chain_helper = *Assert(setup.m_node.chain_helper.get());
+        auto& special_tx = *Assert(setup.m_node.special_tx.get());
         BOOST_CHECK_NO_THROW(
-            rebuilt = chain_helper.special_tx->RebuildListFromBlock(
+            rebuilt = special_tx.RebuildListFromBlock(
                 block, chainman.ActiveChain().Tip(), IsV24Active(chainman), dmnman.GetListAtChainTip(),
                 chainman.ActiveChainstate().CoinsTip(), /*debugLogs=*/false, block_state, mn_list_ret));
     }
diff --git a/src/test/evo_snapshot_tests.cpp b/src/test/evo_snapshot_tests.cpp
index 38d18473d454..dfc34a3031d3 100644
--- a/src/test/evo_snapshot_tests.cpp
+++ b/src/test/evo_snapshot_tests.cpp
@@ -8,7 +8,6 @@
 #include <consensus/amount.h>
 #include <consensus/merkle.h>
 #include <evo/cbtx.h>
-#include <evo/chainhelper.h>
 #include <evo/creditpool.h>
 #include <evo/evodb.h>
 #include <evo/mnhftx.h>
diff --git a/src/test/governance_inv_tests.cpp b/src/test/governance_inv_tests.cpp
index 880670bf862d..2d4caef5e95b 100644
--- a/src/test/governance_inv_tests.cpp
+++ b/src/test/governance_inv_tests.cpp
@@ -3,7 +3,6 @@
 // file COPYING or http://www.opensource.org/licenses/mit-license.php.
 
 #include <common/bloom.h>
-#include <evo/chainhelper.h>
 #include <governance/governance.h>
 #include <governance/net_governance.h>
 #include <governance/object.h>
@@ -47,7 +46,7 @@ struct GovernanceInvSetup : public TestingSetup {
         // Note: mn_metaman is left unloaded. Reaching CGovernanceObject::ProcessVote asserts
         // metaman.IsValid(), so a test that delivers a vote whose parent object exists must
         // load it first (see invalid_vote_is_scored_alike_with_and_without_a_parent_object).
-        m_node.govman = std::make_unique<CGovernanceManager>(*m_node.mn_metaman, *m_node.chainman, *m_node.chain_helper->superblocks, *m_node.dmnman, *m_node.mn_sync);
+        m_node.govman = std::make_unique<CGovernanceManager>(*m_node.mn_metaman, *m_node.chainman, *m_node.sbman, *m_node.dmnman, *m_node.mn_sync);
         // Match runtime preconditions: NetGovernance::AlreadyHave claims we
         // already have the inv when governance isn't loaded (e.g.
         // -disablegovernance), so ConfirmInventoryRequest would never run.
@@ -76,8 +75,6 @@ struct GovernanceInvSetup : public TestingSetup {
         SetMockTime(1'700'000'000s);
     }
     ~GovernanceInvSetup() {
-        // govman holds a reference to chain_helper->superblocks, so it must be reset before chain_helper (matches PrepareShutdown
-        // ordering in init.cpp).
         m_node.peerman->RemoveHandlers();
         m_node.govman.reset();
     }
diff --git a/src/test/governance_superblock_tests.cpp b/src/test/governance_superblock_tests.cpp
index 759bc6e9485c..14f5c5bb837f 100644
--- a/src/test/governance_superblock_tests.cpp
+++ b/src/test/governance_superblock_tests.cpp
@@ -2,16 +2,15 @@
 // Distributed under the MIT software license, see the accompanying
 // file COPYING or http://www.opensource.org/licenses/mit-license.php.
 
-#include <chain.h>
 #include <chainparams.h>
 #include <consensus/amount.h>
 #include <governance/superblock.h>
+#include <masternode/payments.h>
 #include <key.h>
 #include <primitives/transaction.h>
 #include <pubkey.h>
 #include <script/script.h>
 #include <script/standard.h>
-#include <uint256.h>
 
 #include <test/util/setup_common.h>
 
@@ -43,18 +42,11 @@ BOOST_AUTO_TEST_CASE(isvalid_duplicate_payments_require_distinct_outputs)
     const CAmount nPayAmount = 1 * COIN;
 
     // Two identical expected payments (same script, same amount).
-    std::vector<CGovernancePayment> payments;
-    payments.emplace_back(dest, nPayAmount, /*proposalHash=*/uint256());
-    payments.emplace_back(dest, nPayAmount, /*proposalHash=*/uint256::ONE);
-    BOOST_REQUIRE(payments[0].IsValid());
-    BOOST_REQUIRE(payments[1].IsValid());
-
-    CSuperblock sb(nBlockHeight, payments);
-    BOOST_REQUIRE_EQUAL(sb.CountPayments(), 2);
+    const SuperblockStatus superblock{.state = SuperblockStatus::State::Triggered, .payments = {{nPayAmount, scriptPayee}, {nPayAmount, scriptPayee}}};
+    const CAmount nPaymentsLimit = CSuperblock::GetPaymentsLimit(nBlockHeight);
 
     const CScript scriptMinerOrMN = CScript() << OP_RETURN;
     const CAmount blockReward = 500 * COIN;
-    CChain dummy_chain;
 
     // Case 1 (regression, V24): coinbase carries only ONE output matching the
     // duplicate expected payment. With the buggy forward scan that restarted
@@ -66,7 +58,7 @@ BOOST_AUTO_TEST_CASE(isvalid_duplicate_payments_require_distinct_outputs)
         CMutableTransaction txNew;
         txNew.vout.emplace_back(blockReward - nPayAmount, scriptMinerOrMN);
         txNew.vout.emplace_back(nPayAmount, scriptPayee); // single matching output
-        BOOST_CHECK(!sb.IsValid(dummy_chain, CTransaction(txNew), nBlockHeight, blockReward, /*is_v24=*/true));
+        BOOST_CHECK(!IsSuperblockValid(superblock, CTransaction(txNew), blockReward, /*is_v24=*/true, nPaymentsLimit));
     }
 
     // Case 2 (V24): coinbase carries TWO outputs matching the duplicate expected
@@ -76,7 +68,7 @@ BOOST_AUTO_TEST_CASE(isvalid_duplicate_payments_require_distinct_outputs)
         txNew.vout.emplace_back(blockReward - 2 * nPayAmount, scriptMinerOrMN);
         txNew.vout.emplace_back(nPayAmount, scriptPayee);
         txNew.vout.emplace_back(nPayAmount, scriptPayee);
-        BOOST_CHECK(sb.IsValid(dummy_chain, CTransaction(txNew), nBlockHeight, blockReward, /*is_v24=*/true));
+        BOOST_CHECK(IsSuperblockValid(superblock, CTransaction(txNew), blockReward, /*is_v24=*/true, nPaymentsLimit));
     }
 
     // Case 3 (pre-V24): the stricter distinct-output rule is gated behind V24.
@@ -87,7 +79,7 @@ BOOST_AUTO_TEST_CASE(isvalid_duplicate_payments_require_distinct_outputs)
         CMutableTransaction txNew;
         txNew.vout.emplace_back(blockReward - nPayAmount, scriptMinerOrMN);
         txNew.vout.emplace_back(nPayAmount, scriptPayee); // single matching output
-        BOOST_CHECK(sb.IsValid(dummy_chain, CTransaction(txNew), nBlockHeight, blockReward, /*is_v24=*/false));
+        BOOST_CHECK(IsSuperblockValid(superblock, CTransaction(txNew), blockReward, /*is_v24=*/false, nPaymentsLimit));
     }
 }
 
diff --git a/src/test/governance_vote_processing_tests.cpp b/src/test/governance_vote_processing_tests.cpp
index 3317312d477a..bbae436392c2 100644
--- a/src/test/governance_vote_processing_tests.cpp
+++ b/src/test/governance_vote_processing_tests.cpp
@@ -3,7 +3,6 @@
 // file COPYING or http://www.opensource.org/licenses/mit-license.php.
 
 #include <consensus/amount.h>
-#include <evo/chainhelper.h>
 #include <evo/deterministicmns.h>
 #include <governance/governance.h>
 #include <governance/object.h>
@@ -118,7 +117,7 @@ struct GovernanceVoteSetup : public TestChainSetup {
         BOOST_REQUIRE(m_node.mn_sync->IsSynced());
 
         m_node.govman = std::make_unique<CGovernanceManager>(*m_node.mn_metaman, *m_node.chainman,
-                                                             *m_node.chain_helper->superblocks, *m_node.dmnman,
+                                                             *m_node.sbman, *m_node.dmnman,
                                                              *m_node.mn_sync);
         BOOST_REQUIRE(m_node.govman->LoadCache(/*load_cache=*/false));
 
@@ -130,7 +129,7 @@ struct GovernanceVoteSetup : public TestChainSetup {
 
     void TearDown()
     {
-        // govman holds a reference into chain_helper, so it must go first (matches PrepareShutdown
+        // govman holds a reference to node.sbman, so it must go first (matches PrepareShutdown
         // ordering in init.cpp).
         m_node.govman.reset();
         if (g_txindex) {
diff --git a/src/test/masternode_payments_tests.cpp b/src/test/masternode_payments_tests.cpp
index cfaaa983a74c..bd68d9eafb0c 100644
--- a/src/test/masternode_payments_tests.cpp
+++ b/src/test/masternode_payments_tests.cpp
@@ -5,7 +5,9 @@
 #include <masternode/payments.h>
 
 #include <chain.h>
-#include <evo/chainhelper.h>
+#include <evo/deterministicmns.h>
+#include <masternode/sync.h>
+#include <netfulfilledman.h>
 #include <primitives/block.h>
 #include <primitives/transaction.h>
 #include <script/script.h>
@@ -93,7 +95,7 @@ BOOST_AUTO_TEST_CASE(strict_amount_must_match_exactly)
 
 // Regression: mainnet block 332320 sits inside an old-budget cycle window and pays
 // out a budget on top of the block reward. The old budget data is long gone, so a
-// node that is not synced yet (SuperBlockCheckType::NoCheck) has no way to validate
+// node that is not synced yet has no way to validate
 // such a block and must accept it, otherwise it can never sync past that height.
 BOOST_FIXTURE_TEST_CASE(old_budget_window_accepted_while_unsynced, TestingSetup)
 {
@@ -103,8 +105,10 @@ BOOST_FIXTURE_TEST_CASE(old_budget_window_accepted_while_unsynced, TestingSetup)
     BOOST_REQUIRE(nBlockHeight < consensus.nSuperblockStartBlock);
     BOOST_REQUIRE(nBlockHeight % consensus.nBudgetPaymentsCycleBlocks < consensus.nBudgetPaymentsWindowBlocks);
 
-    CBlockIndex pindexPrev;
-    pindexPrev.nHeight = nBlockHeight - 1;
+    const uint256 hash;
+    CBlockIndex pindex;
+    pindex.nHeight = nBlockHeight;
+    pindex.phashBlock = &hash;
 
     constexpr CAmount blockReward{508031847};
     CMutableTransaction coinbase;
@@ -115,19 +119,18 @@ BOOST_FIXTURE_TEST_CASE(old_budget_window_accepted_while_unsynced, TestingSetup)
     CBlock block;
     block.vtx.push_back(MakeTransactionRef(coinbase));
 
-    auto& mn_payments{*Assert(m_node.chain_helper)->mn_payments};
-    LOCK(cs_main);
-    const CChain& active_chain{m_node.chainman->ActiveChain()};
+    const Chainstate& chainstate{m_node.chainman->ActiveChainstate()};
+    const CDeterministicMNList mn_list;
 
     std::string strError;
-    BOOST_CHECK(mn_payments.IsBlockValueValid(active_chain, block, &pindexPrev, blockReward, strError,
-                                              SuperBlockCheckType::NoCheck));
+    BOOST_CHECK(chainstate.IsBlockValueValid(block, &pindex, mn_list, blockReward, strError));
     BOOST_CHECK(strError.empty());
 
     // The enforcing branch is only reached by a node that is synced and has no
     // chainlock at that height, and it still rejects the over-reward block.
-    BOOST_CHECK(!mn_payments.IsBlockValueValid(active_chain, block, &pindexPrev, blockReward, strError,
-                                               SuperBlockCheckType::AllowDuplicates));
+    BOOST_REQUIRE(m_node.netfulfilledman->LoadCache(/*load_cache=*/false));
+    while (!m_node.mn_sync->IsSynced()) m_node.mn_sync->SwitchToNextAsset();
+    BOOST_CHECK(!chainstate.IsBlockValueValid(block, &pindex, mn_list, blockReward, strError));
     BOOST_CHECK_EQUAL(strError, "coinbase pays too much at height 332320 (actual=118108031847 vs limit=508031847), "
                                 "exceeded block reward, old budgets are disabled");
 }
diff --git a/src/test/util/chainstate.h b/src/test/util/chainstate.h
index 0e2c13e8f849..4bd17e0efb63 100644
--- a/src/test/util/chainstate.h
+++ b/src/test/util/chainstate.h
@@ -75,7 +75,7 @@ CreateAndActivateUTXOSnapshot(
             uint256 gen_hash = node.chainman->ActiveChainstate().m_chain[0]->GetBlockHash();
             node.chainman->ResetChainstates();
             node.chainman->InitializeChainstate(
-                node.mempool.get(), *Assert(node.evodb), node.chain_helper);
+                node.mempool.get(), *Assert(node.evodb), *Assert(node.special_tx), *Assert(node.chainlocks), node.isman.get());
             Chainstate& chain = node.chainman->ActiveChainstate();
             Assert(chain.LoadGenesisBlock());
             // These cache values will be corrected shortly in `MaybeRebalanceCaches`.
diff --git a/src/test/util/setup_common.cpp b/src/test/util/setup_common.cpp
index 5fa799d2291e..ec86dfbba9bd 100644
--- a/src/test/util/setup_common.cpp
+++ b/src/test/util/setup_common.cpp
@@ -71,7 +71,6 @@
 #include <coinjoin/coinjoin.h>
 #include <coinjoin/walletman.h>
 #include <evo/cbtx.h>
-#include <evo/chainhelper.h>
 #include <evo/deterministicmns.h>
 #include <evo/evodb.h>
 #include <evo/simplifiedmns.h>
@@ -79,8 +78,10 @@
 #include <evo/specialtxman.h>
 #include <flat-database.h>
 #include <governance/governance.h>
+#include <governance/superblock.h>
 #include <instantsend/instantsend.h>
 #include <llmq/context.h>
+#include <llmq/options.h>
 #include <llmq/signing.h>
 #include <masternode/meta.h>
 #include <masternode/sync.h>
@@ -212,6 +213,8 @@ BasicTestingSetup::BasicTestingSetup(const std::string& chainName, const std::ve
     m_node.netfulfilledman = std::make_unique<CNetFulfilledRequestManager>();
     m_node.sporkman = std::make_unique<CSporkManager>();
     m_node.chainlocks = std::make_unique<chainlock::Chainlocks>(*m_node.sporkman);
+    m_node.sbman = std::make_unique<governance::SuperblockManager>();
+    m_node.mn_sync = std::make_unique<CMasternodeSync>(std::make_unique<NodeSyncNotifierImpl>(*m_node.connman, *m_node.netfulfilledman));
     m_node.evodb = std::make_unique<CEvoDB>(util::DbWrapperParams{.path = m_node.args->GetDataDirNet(), .memory = m_dash_dbs_in_memory, .wipe = true});
     m_node.dmnman = std::make_unique<CDeterministicMNManager>(*m_node.evodb, *m_node.mn_metaman);
     m_node.isman = std::make_unique<llmq::CInstantSendManager>(*m_node.sporkman, util::DbWrapperParams{.path = m_node.args->GetDataDirNet(), .memory = m_dash_dbs_in_memory, .wipe = true});
@@ -266,12 +269,12 @@ ChainTestingSetup::ChainTestingSetup(const std::string& chainName, const std::ve
     const ChainstateManager::Options chainman_opts{
         .chainparams = chainparams,
         .check_block_index = true,
+        .superblock_status = [&sbman = *m_node.sbman](const CDeterministicMNList& mn_list, int height) { return sbman.GetStatus(mn_list, height); },
+        .mn_sync = m_node.mn_sync.get(),
     };
     m_node.chainman = std::make_unique<ChainstateManager>(chainman_opts);
     m_node.chainman->m_blockman.m_block_tree_db = std::make_unique<CBlockTreeDB>(m_cache_sizes.block_tree_db, true);
 
-    m_node.mn_sync = std::make_unique<CMasternodeSync>(std::make_unique<NodeSyncNotifierImpl>(*m_node.connman, *m_node.netfulfilledman));
-
     m_node.clhandler = std::make_unique<chainlock::ChainlockHandler>(*m_node.chainlocks, *m_node.chainman, *m_node.mempool, *m_node.mn_sync);
 
     constexpr int script_check_threads = 2;
@@ -298,7 +301,6 @@ node::ChainstateLoadOptions ChainTestingSetup::ChainstateLoadOptionsForTest()
     options.mempool = Assert(m_node.mempool.get());
     options.isman = Assert(m_node.isman.get());
     options.chainlocks = Assert(m_node.chainlocks.get());
-    options.mn_sync = Assert(m_node.mn_sync.get());
     options.data_dir = Assert(m_node.args)->GetDataDirNet();
     options.block_tree_db_in_memory = m_block_tree_db_in_memory;
     options.coins_db_in_memory = m_coins_db_in_memory;
@@ -314,6 +316,22 @@ node::ChainstateLoadOptions ChainTestingSetup::ChainstateLoadOptionsForTest()
     return options;
 }
 
+void ChainTestingSetup::MakeDashChainContexts(const bool llmq_dbs_wipe)
+{
+    auto& chainman{*Assert(m_node.chainman)};
+
+    LOCK(::cs_main);
+    m_node.special_tx.reset();
+    m_node.llmq_ctx.reset();
+    m_node.llmq_ctx = std::make_unique<LLMQContext>(*m_node.dmnman, *m_node.evodb, chainman,
+                                                    util::DbWrapperParams{.path = m_node.args->GetDataDirNet(), .memory = m_dash_dbs_in_memory, .wipe = llmq_dbs_wipe},
+                                                    llmq::DEFAULT_BLSCHECK_THREADS, llmq::DEFAULT_WORKER_COUNT, llmq::DEFAULT_MAX_RECOVERED_SIGS_AGE);
+    m_node.special_tx = std::make_unique<CSpecialTxProcessor>(*m_node.evodb, *m_node.dmnman,
+                                                              *m_node.llmq_ctx->quorum_block_processor, *m_node.llmq_ctx->qsnapman,
+                                                              chainman, chainman.m_blockman, chainman.GetConsensus(),
+                                                              *Assert(m_node.chainlocks), *m_node.llmq_ctx->qman);
+}
+
 void ChainTestingSetup::LoadVerifyActivateChainstate()
 {
     auto& chainman{*Assert(m_node.chainman)};
@@ -342,6 +360,8 @@ void ChainTestingSetup::LoadVerifyActivateChainstate()
         // here, including the chainlock handler that references the mempool.
         m_node.clhandler.reset();
         m_node.mempool.reset();
+        m_node.special_tx.reset();
+        m_node.llmq_ctx.reset();
         m_node.isman.reset();
         m_node.dmnman.reset();
         m_node.evodb.reset();
@@ -350,11 +370,14 @@ void ChainTestingSetup::LoadVerifyActivateChainstate()
         m_node.isman = std::make_unique<llmq::CInstantSendManager>(*m_node.sporkman, util::DbWrapperParams{.path = m_node.args->GetDataDirNet(), .memory = m_dash_dbs_in_memory, .wipe = true});
         m_node.mempool = std::make_unique<CTxMemPool>(MemPoolOptionsForTest(m_node));
         m_node.clhandler = std::make_unique<chainlock::ChainlockHandler>(*m_node.chainlocks, chainman, *m_node.mempool, *m_node.mn_sync);
+        MakeDashChainContexts(/*llmq_dbs_wipe=*/true);
         options = ChainstateLoadOptionsForTest();
+    } else {
+        MakeDashChainContexts(/*llmq_dbs_wipe=*/false);
     }
 
-    auto [status, error] = LoadChainstate(chainman, m_cache_sizes, options, *m_node.evodb, *m_node.dmnman, m_node.llmq_ctx,
-                                          m_node.chain_helper);
+    auto [status, error] = LoadChainstate(chainman, m_cache_sizes, options, *m_node.evodb, *m_node.dmnman,
+                                          *m_node.special_tx);
     assert(status == node::ChainstateLoadStatus::SUCCESS);
 
     std::tie(status, error) = VerifyLoadedChainstate(chainman, options, *Assert(m_node.evodb), [](bool bls_state) {
@@ -434,12 +457,12 @@ TestingSetup::~TestingSetup()
         m_node.connman->Stop();
     }
 
-    // govman holds a reference to chain_helper->superblocks, so it must be
-    // reset before chain_helper is destroyed (matches PrepareShutdown ordering
-    // in init.cpp). Keep this defensive for fixtures that construct govman.
+    // govman holds a reference to node.sbman, which NodeContext destroys
+    // last, but reset it here anyway to match PrepareShutdown ordering in
+    // init.cpp for fixtures that construct govman.
     m_node.govman.reset();
 
-    m_node.chain_helper.reset();
+    m_node.special_tx.reset();
     m_node.llmq_ctx.reset();
 }
 
@@ -593,7 +616,7 @@ CBlock TestChainSetup::CreateBlock(
         CDeterministicMNList mn_list;
         const CBlockIndex* pindexPrev{chainstate.m_chain.Tip()};
         const bool is_v24_active{DeploymentActiveAfter(pindexPrev, chainstate.m_chainman, Consensus::DEPLOYMENT_V24)};
-        if (!chainstate.ChainHelper().special_tx->BuildNewListFromBlock(block, pindexPrev, is_v24_active,
+        if (!chainstate.m_special_tx.BuildNewListFromBlock(block, pindexPrev, is_v24_active,
                                                                         chainstate.CoinsTip(), true, state, mn_list)) {
             Assert(false);
         }
diff --git a/src/test/util/setup_common.h b/src/test/util/setup_common.h
index 73652650a83d..95852c31ca38 100644
--- a/src/test/util/setup_common.h
+++ b/src/test/util/setup_common.h
@@ -93,6 +93,11 @@ struct ChainTestingSetup : public BasicTestingSetup {
     // The options LoadVerifyActivateChainstate() feeds to LoadChainstate();
     // exposed for tests that drive LoadChainstate() to an expected failure.
     node::ChainstateLoadOptions ChainstateLoadOptionsForTest();
+
+    // (Re)creates m_node.llmq_ctx and m_node.special_tx, which must exist
+    // before Chainstate objects can be created; exposed for tests that call
+    // InitializeChainstate() or LoadChainstate() themselves.
+    void MakeDashChainContexts(bool llmq_dbs_wipe);
 };
 
 /** Testing setup that configures a complete environment.
diff --git a/src/test/validation_chainstate_tests.cpp b/src/test/validation_chainstate_tests.cpp
index a3e2fed8239e..7699c2d07186 100644
--- a/src/test/validation_chainstate_tests.cpp
+++ b/src/test/validation_chainstate_tests.cpp
@@ -52,7 +52,9 @@ BOOST_AUTO_TEST_CASE(validation_chainstate_resize_caches)
 {
     ChainstateManager& manager = *Assert(m_node.chainman);
     CTxMemPool& mempool = *Assert(m_node.mempool);
-    Chainstate& c1 = WITH_LOCK(cs_main, return manager.InitializeChainstate(&mempool, *m_node.evodb, m_node.chain_helper));
+    MakeDashChainContexts(/*llmq_dbs_wipe=*/false);
+    Chainstate& c1 = WITH_LOCK(cs_main, return manager.InitializeChainstate(&mempool, *m_node.evodb, *Assert(m_node.special_tx),
+                                                                            *Assert(m_node.chainlocks), m_node.isman.get()));
     c1.InitCoinsDB(
         /*cache_size_bytes=*/1 << 23, /*in_memory=*/true, /*should_wipe=*/false);
     WITH_LOCK(::cs_main, c1.InitCoinsCache(1 << 23));
diff --git a/src/test/validation_chainstatemanager_tests.cpp b/src/test/validation_chainstatemanager_tests.cpp
index e8c97241fd57..f3bb7e352deb 100644
--- a/src/test/validation_chainstatemanager_tests.cpp
+++ b/src/test/validation_chainstatemanager_tests.cpp
@@ -4,11 +4,10 @@
 //
 #include <chainparams.h>
 #include <consensus/validation.h>
-#include <evo/chainhelper.h>
 #include <evo/deterministicmns.h>
+#include <evo/specialtxman.h>
+#include <governance/superblock.h>
 #include <kernel/disconnected_transactions.h>
-#include <llmq/context.h>
-#include <llmq/options.h>
 #include <node/chainstate.h>
 #include <node/utxo_snapshot.h>
 #include <random.h>
@@ -26,6 +25,7 @@
 #include <evo/evodb.h>
 #include <llmq/blockprocessor.h>
 #include <llmq/commitment.h>
+#include <llmq/context.h>
 #include <llmq/quorumsman.h>
 #include <llmq/signing.h>
 #include <llmq/signing_shares.h>
@@ -54,29 +54,6 @@ void SeedSnapshotMarker(CEvoDB& evodb, const uint256& hash)
 
 BOOST_FIXTURE_TEST_SUITE(validation_chainstatemanager_tests, ChainTestingSetup)
 
-static void DashChainstateSetup(ChainstateManager& chainman,
-                         node::NodeContext& node,
-                         bool llmq_dbs_in_memory,
-                         bool llmq_dbs_wipe)
-{
-    LOCK(::cs_main);
-    node.llmq_ctx.reset();
-    node.llmq_ctx = std::make_unique<LLMQContext>(*node.dmnman, *node.evodb, chainman,
-                                                  util::DbWrapperParams{.path = node.args->GetDataDirNet(), .memory = llmq_dbs_in_memory, .wipe = llmq_dbs_wipe},
-                                                  llmq::DEFAULT_BLSCHECK_THREADS, llmq::DEFAULT_WORKER_COUNT, llmq::DEFAULT_MAX_RECOVERED_SIGS_AGE);
-    // Initialize chain_helper
-    node.chain_helper.reset();
-    node.chain_helper = std::make_unique<CChainstateHelper>(*node.evodb, *node.dmnman, *Assert(node.mn_sync), *Assert(node.isman), *(node.llmq_ctx->quorum_block_processor),
-                                                            *(node.llmq_ctx->qsnapman), chainman, chainman.m_blockman, chainman.GetConsensus(),
-                                                            *Assert(node.chainlocks), *(node.llmq_ctx->qman));
-}
-
-static void DashChainstateSetupClose(node::NodeContext& node)
-{
-    node.chain_helper.reset();
-    node.llmq_ctx.reset();
-}
-
 //! Basic tests for ChainstateManager.
 //!
 //! First create a legacy (IBD) chainstate, then create a snapshot chainstate.
@@ -91,14 +68,14 @@ BOOST_AUTO_TEST_CASE(chainstatemanager)
 
     // Create a legacy (IBD) chainstate.
     //
-    Chainstate& c1 = WITH_LOCK(::cs_main, return manager.InitializeChainstate(&mempool, evodb, m_node.chain_helper));
+    MakeDashChainContexts(/*llmq_dbs_wipe=*/false);
+    Chainstate& c1 = WITH_LOCK(::cs_main, return manager.InitializeChainstate(&mempool, evodb, *Assert(m_node.special_tx),
+                                                                              *Assert(m_node.chainlocks), m_node.isman.get()));
     chainstates.push_back(&c1);
     c1.InitCoinsDB(
         /*cache_size_bytes=*/1 << 23, /*in_memory=*/true, /*should_wipe=*/false);
     WITH_LOCK(::cs_main, c1.InitCoinsCache(1 << 23));
 
-    DashChainstateSetup(manager, m_node, /*llmq_dbs_in_memory=*/true, /*llmq_dbs_wipe=*/false);
-
     BOOST_REQUIRE(c1.LoadGenesisBlock());
     BlockValidationState val_state;
     BOOST_CHECK(c1.ActivateBestChain(val_state, nullptr));
@@ -121,8 +98,6 @@ BOOST_AUTO_TEST_CASE(chainstatemanager)
 
     BOOST_CHECK(!manager.SnapshotBlockhash().has_value());
 
-    DashChainstateSetupClose(m_node);
-
     // Create a snapshot-based chainstate.
     //
     const uint256 snapshot_blockhash = active_tip->GetBlockHash();
@@ -137,8 +112,6 @@ BOOST_AUTO_TEST_CASE(chainstatemanager)
     BOOST_CHECK_EQUAL(c2.GetMempool(), &mempool);
     BOOST_CHECK(!c1.GetMempool());
 
-    DashChainstateSetup(manager, m_node, /*llmq_dbs_in_memory=*/true, /*llmq_dbs_wipe=*/false);
-
     BOOST_CHECK_EQUAL(manager.SnapshotBlockhash().value(), snapshot_blockhash);
 
     c2.InitCoinsDB(
@@ -171,7 +144,8 @@ BOOST_AUTO_TEST_CASE(chainstatemanager)
     // Let scheduler events finish running to avoid accessing memory that is going to be unloaded
     SyncWithValidationInterfaceQueue();
 
-    DashChainstateSetupClose(m_node);
+    m_node.special_tx.reset();
+    m_node.llmq_ctx.reset();
     // dmnman holds a reference to m_node.evodb, it mustn't outlive it
     m_node.dmnman.reset();
 }
@@ -457,11 +431,14 @@ struct SnapshotTestSetup : TestChain100Setup {
                     cs->ForceFlushStateToDisk();
                 }
             }
-            DashChainstateSetupClose(m_node);
+            m_node.special_tx.reset();
+            m_node.llmq_ctx.reset();
             chainman.ResetChainstates();
             BOOST_CHECK_EQUAL(chainman.GetAll().size(), 0);
             const ChainstateManager::Options chainman_opts{
                 .chainparams = ::Params(),
+                .superblock_status = [&sbman = *m_node.sbman](const CDeterministicMNList& mn_list, int height) { return sbman.GetStatus(mn_list, height); },
+                .mn_sync = m_node.mn_sync.get(),
             };
             // For robustness, ensure the old manager is destroyed before creating a
             // new one.
@@ -887,8 +864,10 @@ BOOST_FIXTURE_TEST_CASE(chainstatemanager_snapshot_init_missing_evodb_marker, Sn
     BOOST_REQUIRE(WITH_LOCK(::cs_main, return m_node.evodb->CommitRootTransaction(EvoDbIdentity::SNAPSHOT)));
 
     ChainstateManager& restarted = this->SimulateNodeRestart();
+    MakeDashChainContexts(/*llmq_dbs_wipe=*/false);
     WITH_LOCK(::cs_main, restarted.InitializeChainstate(
-        m_node.mempool.get(), *m_node.evodb, m_node.chain_helper));
+        m_node.mempool.get(), *m_node.evodb, *Assert(m_node.special_tx),
+        *Assert(m_node.chainlocks), m_node.isman.get()));
 
     bilingual_str error;
     BOOST_CHECK(!WITH_LOCK(::cs_main, return restarted.DetectSnapshotChainstate(m_node.mempool.get(), error)));
@@ -1219,13 +1198,14 @@ BOOST_FIXTURE_TEST_CASE(chainstatemanager_snapshot_missing_base_fails_load, Snap
     fs::remove_all(gArgs.GetDataDirNet() / "blocks" / "index");
 
     ChainstateManager& chainman = *Assert(m_node.chainman);
+    MakeDashChainContexts(/*llmq_dbs_wipe=*/false);
     node::ChainstateLoadStatus status;
     bilingual_str error;
     {
         ASSERT_DEBUG_LOG("missing from the block index");
         std::tie(status, error) = node::LoadChainstate(chainman, m_cache_sizes, ChainstateLoadOptionsForTest(),
-                                                       *m_node.evodb, *m_node.dmnman, m_node.llmq_ctx,
-                                                       m_node.chain_helper);
+                                                       *m_node.evodb, *m_node.dmnman,
+                                                       *m_node.special_tx);
     }
     BOOST_CHECK(status == node::ChainstateLoadStatus::FAILURE);
 }
diff --git a/src/validation.cpp b/src/validation.cpp
index 3e20f8617c8b..4ad368546a03 100644
--- a/src/validation.cpp
+++ b/src/validation.cpp
@@ -63,14 +63,16 @@
 #include <chainlock/chainlock.h>
 #include <evo/assetlocktx.h>
 #include <evo/cbtx.h>
-#include <evo/chainhelper.h>
 #include <evo/creditpool.h>
 #include <evo/deterministicmns.h>
 #include <evo/evodb.h>
 #include <evo/specialtx.h>
 #include <evo/specialtxman.h>
+#include <instantsend/instantsend.h>
 #include <instantsend/lock.h>
+#include <key_io.h>
 #include <masternode/payments.h>
+#include <masternode/sync.h>
 #include <stats/client.h>
 #include <util/std23.h>
 
@@ -565,7 +567,8 @@ class MemPoolAccept
         m_view(&m_dummy),
         m_viewmempool(&active_chainstate.CoinsTip(), m_pool),
         m_active_chainstate(active_chainstate),
-        m_chain_helper(active_chainstate.ChainHelper()),
+        m_special_tx(active_chainstate.m_special_tx),
+        m_isman(active_chainstate.m_isman),
         m_limits{m_pool.m_limits}
     {
     }
@@ -794,7 +797,8 @@ class MemPoolAccept
     CCoinsViewMemPool m_viewmempool;
     CCoinsView m_dummy;
     Chainstate& m_active_chainstate;
-    CChainstateHelper& m_chain_helper;
+    CSpecialTxProcessor& m_special_tx;
+    llmq::CInstantSendManager* const m_isman;
 
     CTxMemPool::Limits m_limits;
 };
@@ -804,7 +808,7 @@ bool MemPoolAccept::CheckSpecialTxForMempool(const CTransaction& tx, SpecialTxRu
     const CChain& chain{m_active_chainstate.m_chain};
     const auto check_at = [&](const CBlockIndex* pindex,
                               TxValidationState& check_state) EXCLUSIVE_LOCKS_REQUIRED(::cs_main) {
-        return m_chain_helper.special_tx->CheckSpecialTx(tx, pindex, rules, m_active_chainstate.CoinsTip(),
+        return m_special_tx.CheckSpecialTx(tx, pindex, rules, m_active_chainstate.CoinsTip(),
                                                          /*check_sigs=*/true, check_state);
     };
     const auto payload{IsAssetUnlockWithStableTxid(tx) ? GetTxPayload<CAssetUnlockPayload>(tx) : std::nullopt};
@@ -888,7 +892,7 @@ bool MemPoolAccept::PreChecks(ATMPArgs& args, Workspace& ws)
         return state.Invalid(TxValidationResult::TX_CONFLICT, "txn-already-in-mempool");
     }
 
-    if (auto conflictLockOpt = m_chain_helper.ConflictingISLockIfAny(tx); conflictLockOpt.has_value()) {
+    if (auto conflictLockOpt = m_isman ? m_isman->ConflictingISLockIfAny(tx) : std::nullopt; conflictLockOpt.has_value()) {
         auto& [_, conflict_txid] = conflictLockOpt.value();
 
         uint256 hashBlock;
@@ -899,7 +903,7 @@ bool MemPoolAccept::PreChecks(ATMPArgs& args, Workspace& ws)
         return state.Invalid(TxValidationResult::TX_CONFLICT_LOCK, "tx-txlock-conflict");
     }
 
-    if (m_chain_helper.IsInstantSendWaitingForTx(hash)) {
+    if (m_isman && m_isman->IsWaitingForTx(hash)) {
         m_pool.removeConflicts(tx);
         m_pool.removeProTxConflicts(tx);
         m_pool.removeAssetUnlockConflicts(tx);
@@ -927,7 +931,7 @@ bool MemPoolAccept::PreChecks(ATMPArgs& args, Workspace& ws)
     // call after startup may reconstruct the pool from the nearest disk snapshot.
     if (const auto opt_unlock = tx.IsPlatformTransfer() ? GetTxPayload<CAssetUnlockPayload>(tx) : std::nullopt) {
         try {
-            if (m_chain_helper.credit_pool_manager->GetCreditPool(m_active_chainstate.m_chain.Tip())
+            if (m_special_tx.m_cpoolman->GetCreditPool(m_active_chainstate.m_chain.Tip())
                     .indexes.Contains(opt_unlock->getIndex())) {
                 return state.Invalid(TxValidationResult::TX_CONFLICT, "txn-already-known");
             }
@@ -1397,7 +1401,7 @@ std::optional<MempoolAcceptResult> MemPoolAccept::TryAssetUnlockRefresh(const CT
     // and quorum signature. Everything the txid covers is identical to the held instance and
     // was validated when it was admitted.
     const CBlockIndex* tip{m_active_chainstate.m_chain.Tip()};
-    if (!m_chain_helper.special_tx->CheckSpecialTx(*ptx, tip, GetSpecialTxRules(tip, m_active_chainstate.m_chainman),
+    if (!m_special_tx.CheckSpecialTx(*ptx, tip, GetSpecialTxRules(tip, m_active_chainstate.m_chainman),
                                                    m_active_chainstate.CoinsTip(),
                                                    /*check_sigs=*/true, state)) {
         return MempoolAcceptResult::Failure(state);
@@ -1888,6 +1892,24 @@ CAmount GetBlockSubsidy(const CBlockIndex* const pindex, const Consensus::Params
     return GetBlockSubsidyInner(pindex->pprev->nBits, pindex->pprev->nHeight, consensusParams, isV20Active);
 }
 
+CAmount GetSuperblockPaymentsLimit(int nBlockHeight, const Consensus::Params& consensusParams)
+{
+    if (!IsSuperblockHeight(nBlockHeight, consensusParams)) {
+        return 0;
+    }
+
+    const bool fV20Active{nBlockHeight >= consensusParams.V20Height};
+
+    // min subsidy for high diff networks and vice versa
+    int nBits = consensusParams.fPowAllowMinDifficultyBlocks ? UintToArith256(consensusParams.powLimit).GetCompact() : 1;
+    // some part of all blocks issued during the cycle goes to superblock, see GetBlockSubsidy
+    CAmount nSuperblockPartOfSubsidy = GetSuperblockSubsidyInner(nBits, nBlockHeight - 1, consensusParams, fV20Active);
+    CAmount nPaymentsLimit = nSuperblockPartOfSubsidy * consensusParams.nSuperblockCycle;
+    LogPrint(BCLog::GOBJECT, "%s -- Valid superblock height %d, payments max %lld\n", __func__, nBlockHeight, nPaymentsLimit);
+
+    return nPaymentsLimit;
+}
+
 CoinsViews::CoinsViews(
     fs::path ldb_name,
     size_t cache_size_bytes,
@@ -1906,14 +1928,18 @@ Chainstate::Chainstate(CTxMemPool* mempool,
                          BlockManager& blockman,
                          ChainstateManager& chainman,
                          CEvoDB& evoDb,
-                         const std::unique_ptr<CChainstateHelper>& chain_helper,
+                         CSpecialTxProcessor& special_tx,
+                         const chainlock::Chainlocks& chainlocks,
+                         llmq::CInstantSendManager* isman,
                          std::optional<uint256> from_snapshot_blockhash)
     : m_mempool(mempool),
-      m_chain_helper(chain_helper),
       m_evoDb(evoDb),
       m_blockman(blockman),
       m_chainman(chainman),
-      m_from_snapshot_blockhash(from_snapshot_blockhash) {}
+      m_from_snapshot_blockhash(from_snapshot_blockhash),
+      m_special_tx{special_tx},
+      m_chainlocks{chainlocks},
+      m_isman{isman} {}
 
 ::EvoDbIdentity Chainstate::EvoDbIdentity() const
 {
@@ -2282,8 +2308,6 @@ int ApplyTxInUndo(Coin&& undo, CCoinsViewCache& view, const COutPoint& out)
 DisconnectResult Chainstate::DisconnectBlock(const CBlock& block, const CBlockIndex* pindex, CCoinsViewCache& view)
 {
     AssertLockHeld(cs_main);
-    assert(m_chain_helper);
-
     bool fDIP0003Active = DeploymentActiveAt(*pindex, m_chainman.GetConsensus(), Consensus::DEPLOYMENT_DIP0003);
     if (fDIP0003Active && !m_evoDb.VerifyBestBlock(EvoDbIdentity(), pindex->GetBlockHash())) {
         // Nodes that upgraded after DIP3 activation will have to reindex to ensure evodb consistency
@@ -2307,7 +2331,7 @@ DisconnectResult Chainstate::DisconnectBlock(const CBlock& block, const CBlockIn
     }
 
     MNListUpdates mnlist_updates;
-    if (!m_chain_helper->special_tx->UndoSpecialTxsInBlock(*this, block, pindex, mnlist_updates)) {
+    if (!m_special_tx.UndoSpecialTxsInBlock(*this, block, pindex, mnlist_updates)) {
         LogError("DisconnectBlock(): UndoSpecialTxsInBlock failed\n");
         return DISCONNECT_FAILED;
     }
@@ -2463,6 +2487,194 @@ static SteadyClock::duration time_index{};
 static SteadyClock::duration time_total{};
 static int64_t num_blocks_total = 0;
 
+bool Chainstate::IsSuperblockValidationRequired(const CBlockIndex* const pindex) const
+{
+    if (m_chainlocks.GetBestChainLockHeight() >= pindex->nHeight) {
+        LogPrint(BCLog::MNPAYMENTS, "%s -- validation of chainlocked block=%s is skipped\n", __func__, pindex->GetBlockHash().ToString());
+        return false;
+    }
+    if (!m_chainman.m_options.mn_sync || !m_chainman.m_options.mn_sync->IsSynced()) {
+        LogPrint(BCLog::MNPAYMENTS, "%s -- WARNING! Node is not fully synced, checked superblock for block=%s max bounds only\n", __func__, pindex->GetBlockHash().ToString());
+        return false;
+    }
+    return true;
+}
+
+[[nodiscard]] static bool IsOldBudgetBlockValueValid(const CBlock& block, const int nBlockHeight, const CAmount blockReward, std::string& strErrorRet, const bool enforce,
+                                                     const Consensus::Params& consensus_params)
+{
+    bool isBlockRewardValueMet = (block.vtx[0]->GetValueOut() <= blockReward);
+
+    if (nBlockHeight < consensus_params.nBudgetPaymentsStartBlock) {
+        strErrorRet = strprintf("Incorrect block %d, old budgets are not activated yet", nBlockHeight);
+        return false;
+    }
+
+    if (nBlockHeight >= consensus_params.nSuperblockStartBlock) {
+        strErrorRet = strprintf("Incorrect block %d, old budgets are no longer active", nBlockHeight);
+        return false;
+    }
+
+    // we are still using budgets, but we have no data about them anymore,
+    // all we know is predefined budget cycle and window
+
+    int nOffset = nBlockHeight % consensus_params.nBudgetPaymentsCycleBlocks;
+    if (nOffset < consensus_params.nBudgetPaymentsWindowBlocks) {
+        // NOTE: old budget system is disabled since 12.1
+        if (!enforce) {
+            // historical mainnet blocks in this window do pay old budgets and we have no
+            // data to validate them with, so rely on online nodes (all networks)
+            LogPrint(BCLog::GOBJECT, "%s -- WARNING! Skipping old budget block value checks, accepting block\n", __func__);
+            return true;
+        }
+        // no old budget blocks should be accepted here on mainnet,
+        // testnet/devnet/regtest should produce regular blocks only
+        if(!isBlockRewardValueMet) {
+            strErrorRet = strprintf("coinbase pays too much at height %d (actual=%d vs limit=%d), exceeded block reward, old budgets are disabled",
+                                    nBlockHeight, block.vtx[0]->GetValueOut(), blockReward);
+        }
+        return isBlockRewardValueMet;
+    }
+    if(!isBlockRewardValueMet) {
+        strErrorRet = strprintf("coinbase pays too much at height %d (actual=%d vs limit=%d), exceeded block reward, block is not in old budget cycle window",
+                                nBlockHeight, block.vtx[0]->GetValueOut(), blockReward);
+    }
+    return isBlockRewardValueMet;
+}
+
+/**
+* IsBlockValueValid
+*
+*   Determine if coinbase outgoing created money is the correct value
+*
+*   Why is this needed?
+*   - In Dash some blocks are superblocks, which output much higher amounts of coins
+*   - Other blocks are 10% lower in outgoing value, so in total, no extra coins are created
+*   - When non-superblocks are detected, the normal schedule should be maintained
+*/
+bool Chainstate::IsBlockValueValid(const CBlock& block, const CBlockIndex* pindex, const CDeterministicMNList& mn_list, const CAmount blockReward, std::string& strErrorRet) const
+{
+    const Consensus::Params& consensus_params{m_chainman.GetConsensus()};
+    const int nBlockHeight{pindex->nHeight};
+    bool isBlockRewardValueMet = (block.vtx[0]->GetValueOut() <= blockReward);
+
+    strErrorRet = "";
+
+    if (nBlockHeight < consensus_params.nBudgetPaymentsStartBlock) {
+        // old budget system is not activated yet, just make sure we do not exceed the regular block reward
+        if(!isBlockRewardValueMet) {
+            strErrorRet = strprintf("coinbase pays too much at height %d (actual=%d vs limit=%d), exceeded block reward, old budgets are not activated yet",
+                                    nBlockHeight, block.vtx[0]->GetValueOut(), blockReward);
+        }
+        return isBlockRewardValueMet;
+    } else if (nBlockHeight < consensus_params.nSuperblockStartBlock) {
+        // superblocks are not enabled yet, check if we can pass old budget rules
+        return IsOldBudgetBlockValueValid(block, nBlockHeight, blockReward, strErrorRet, IsSuperblockValidationRequired(pindex), consensus_params);
+    }
+
+    LogPrint(BCLog::MNPAYMENTS, "block.vtx[0]->GetValueOut() %lld <= blockReward %lld\n", block.vtx[0]->GetValueOut(), blockReward);
+
+    const CAmount nSuperblockPaymentsLimit{GetSuperblockPaymentsLimit(nBlockHeight, consensus_params)};
+    CAmount nSuperblockMaxValue =  blockReward + nSuperblockPaymentsLimit;
+    bool isSuperblockMaxValueMet = (block.vtx[0]->GetValueOut() <= nSuperblockMaxValue);
+
+    LogPrint(BCLog::GOBJECT, "block.vtx[0]->GetValueOut() %lld <= nSuperblockMaxValue %lld\n", block.vtx[0]->GetValueOut(), nSuperblockMaxValue);
+
+    if (!IsSuperblockHeight(nBlockHeight, consensus_params)) {
+        // can't possibly be a superblock, so lets just check for block reward limits
+        if (!isBlockRewardValueMet) {
+            strErrorRet = strprintf("coinbase pays too much at height %d (actual=%d vs limit=%d), exceeded block reward, only regular blocks are allowed at this height",
+                                    nBlockHeight, block.vtx[0]->GetValueOut(), blockReward);
+        }
+        return isBlockRewardValueMet;
+    }
+
+    // bail out in case superblock limits were exceeded
+    if (!isSuperblockMaxValueMet) {
+        strErrorRet = strprintf("coinbase pays too much at height %d (actual=%d vs limit=%d), exceeded superblock max value",
+                                nBlockHeight, block.vtx[0]->GetValueOut(), nSuperblockMaxValue);
+        return false;
+    }
+
+    if (!IsSuperblockValidationRequired(pindex)) return true;
+
+    SuperblockStatus superblock;
+    if (m_chainman.m_options.superblock_status) {
+        superblock = m_chainman.m_options.superblock_status(mn_list, nBlockHeight);
+    }
+    if (superblock.state == SuperblockStatus::State::ValidationDisabled) {
+        LogPrint(BCLog::MNPAYMENTS, "%s -- WARNING! Not enough data, checked superblock max bounds only\n", __func__);
+        // not enough data for full checks but at least we know that the superblock limits were honored.
+        // We rely on the network to have followed the correct chain in this case
+        return true;
+    }
+
+    // we are synced and possibly on a superblock now
+
+    if (superblock.state == SuperblockStatus::State::NotTriggered) {
+        // we are on a valid superblock height but a superblock was not triggered
+        // revert to block reward limits in this case
+        if(!isBlockRewardValueMet) {
+            strErrorRet = strprintf("coinbase pays too much at height %d (actual=%d vs limit=%d), exceeded block reward, no triggered superblock detected",
+                                    nBlockHeight, block.vtx[0]->GetValueOut(), blockReward);
+        }
+        return isBlockRewardValueMet;
+    }
+
+    // this actually also checks for correct payees and not only amount
+    const bool is_v24{DeploymentActiveAfter(pindex->pprev, m_chainman, Consensus::DEPLOYMENT_V24)};
+    if (!IsSuperblockValid(superblock, *block.vtx[0], blockReward, is_v24, nSuperblockPaymentsLimit)) {
+        // triggered but invalid? that's weird
+        LogPrintf("%s -- ERROR! Invalid superblock detected at height %d: %s", __func__, nBlockHeight, block.vtx[0]->ToString()); /* Continued */
+        // should NOT allow invalid superblocks, when superblocks are enabled
+        strErrorRet = strprintf("invalid superblock detected at height %d", nBlockHeight);
+        return false;
+    }
+
+    // we got a valid superblock
+    return true;
+}
+
+bool Chainstate::IsBlockPayeeValid(const CBlock& block, const CBlockIndex* pindex, const CDeterministicMNList& mn_list, const CAmount blockSubsidy, const CAmount feeReward) const
+{
+    const Consensus::Params& consensus_params{m_chainman.GetConsensus()};
+    const CTransaction& txNew{*block.vtx[0]};
+    const int nBlockHeight{pindex->nHeight};
+    if (!DeploymentDIP0003Enforced(nBlockHeight, consensus_params)) {
+        // can't verify historical blocks here
+        return true;
+    }
+
+    std::vector<CTxOut> voutMasternodePayments;
+    const MnRewardEra era{GetMnRewardEraAfter(pindex->pprev, m_chainman)};
+    if (!GetMasternodePayments(mn_list, pindex->pprev, blockSubsidy, feeReward, era, consensus_params, voutMasternodePayments)) {
+        LogPrintf("%s -- ERROR! Failed to get payees for block at height %s\n", __func__, nBlockHeight);
+        return true;
+    }
+
+    // With strict multiplicity (v24 active) each expected payment must be matched by a
+    // distinct coinbase output: duplicate expected outputs require duplicate coinbase
+    // outputs. Pre-v24 retains the legacy existence-only check to avoid tightening
+    // historical validation.
+    const bool strict_multiplicity{DeploymentActiveAfter(pindex->pprev, m_chainman, Consensus::DEPLOYMENT_V24)};
+    const int unmatched_idx = FindUnmatchedMasternodePayment(voutMasternodePayments, txNew.vout, strict_multiplicity);
+    if (unmatched_idx >= 0) {
+        const auto& txout = voutMasternodePayments[unmatched_idx];
+        std::string str_payout;
+        if (CTxDestination dest; ExtractDestination(txout.scriptPubKey, dest)) {
+            str_payout = "address=" + EncodeDestination(dest);
+        } else {
+            str_payout = "scriptPubKey=" + HexStr(txout.scriptPubKey);
+        }
+        LogPrintf("%s -- ERROR! Failed to find expected payee %s amount=%lld height=%d\n",
+                  __func__, str_payout, txout.nValue, nBlockHeight);
+        LogPrintf("%s -- ERROR! Invalid masternode payment detected at height %d: %s", __func__, nBlockHeight, txNew.ToString()); /* Continued */
+        return false;
+    }
+    LogPrint(BCLog::MNPAYMENTS, "%s -- Valid masternode payment at height %d: %s", __func__, nBlockHeight, txNew.ToString()); /* Continued */
+    return true;
+}
+
 /** Apply the effects of this block (with given index) on the UTXO set represented by coins.
  *  Validity checks that depend on the UTXO set are also done; ConnectBlock()
  *  can fail if those validity checks fail (among other reasons). */
@@ -2479,8 +2691,6 @@ bool Chainstate::ConnectBlock(const CBlock& block, BlockValidationState& state,
     assert(*pindex->phashBlock == block_hash);
     const bool parallel_script_checks{scriptcheckqueue.HasThreads()};
 
-    assert(m_chain_helper);
-
     // The scheme in force while a block is processed is the one its parent left
     // behind; ProcessSpecialTxsInBlock flips it to basic afterwards when V19
     // activates. Establish it here rather than inheriting the caller's, because
@@ -2513,7 +2723,7 @@ bool Chainstate::ConnectBlock(const CBlock& block, BlockValidationState& state,
         return false;
     }
 
-    if (pindex->pprev && pindex->phashBlock && m_chain_helper->HasConflictingChainLock(pindex->nHeight, pindex->GetBlockHash())) {
+    if (pindex->pprev && pindex->phashBlock && m_chainlocks.HasConflictingChainLock(pindex->nHeight, pindex->GetBlockHash())) {
         LogPrintf("ERROR: %s: conflicting with chainlock\n", __func__);
         return state.Invalid(BlockValidationResult::BLOCK_CHAINLOCK, "bad-chainlock");
     }
@@ -2660,7 +2870,7 @@ bool Chainstate::ConnectBlock(const CBlock& block, BlockValidationState& state,
 
     // MUST process special txes before updating UTXO to ensure consistency between mempool and block processing
     MNListUpdates mnlist_updates;
-    if (!m_chain_helper->special_tx->ProcessSpecialTxsInBlock(*this, m_chain, block, pindex, special_tx_rules, view,
+    if (!m_special_tx.ProcessSpecialTxsInBlock(*this, m_chain, block, pindex, special_tx_rules, view,
                                                               blockSubsidy, fJustCheck, fScriptChecks, state,
                                                               mnlist_updates)) {
         LogError("ConnectBlock(DASH): ProcessSpecialTxsInBlock for block %s failed with %s\n",
@@ -2798,16 +3008,16 @@ bool Chainstate::ConnectBlock(const CBlock& block, BlockValidationState& state,
 
     // DASH : CHECK TRANSACTIONS FOR INSTANTSEND
 
-    if (!IsInitialBlockDownload()) {
+    if (m_isman != nullptr && !IsInitialBlockDownload()) {
         // Require other nodes to comply, send them some data in case they are missing it.
-        const bool has_chainlock = m_chain_helper->HasChainLock(pindex->nHeight, pindex->GetBlockHash());
+        const bool has_chainlock = m_chainlocks.HasChainLock(pindex->nHeight, pindex->GetBlockHash());
         for (const auto& tx : block.vtx) {
             if (!instantsend::HasLockInputs(*tx)) continue;
-            while (auto conflictLockOpt = m_chain_helper->ConflictingISLockIfAny(*tx)) {
+            while (auto conflictLockOpt = m_isman->ConflictingISLockIfAny(*tx)) {
                 auto [conflict_islock_hash, conflict_txid] = conflictLockOpt.value();
                 if (has_chainlock) {
                     LogPrint(BCLog::ALL, "ConnectBlock(DASH): chain-locked transaction %s overrides islock %s\n", tx->GetHash().ToString(), conflict_islock_hash.ToString());
-                    m_chain_helper->RemoveConflictingISLockByTx(*tx);
+                    m_isman->RemoveConflictingISLockByTx(*tx);
                 } else {
                     // The node which relayed this should switch to correct chain.
                     // TODO: relay instantsend data/proof.
@@ -2838,12 +3048,7 @@ bool Chainstate::ConnectBlock(const CBlock& block, BlockValidationState& state,
              Ticks<SecondsDouble>(time_subsidy),
              Ticks<MillisecondsDouble>(time_subsidy) / num_blocks_total);
 
-    const SuperBlockCheckType check_superblock = !m_chain_helper->IsSuperblockValidationRequired(pindex)
-        ? SuperBlockCheckType::NoCheck
-        : special_tx_rules.v24 ? SuperBlockCheckType::DisallowDuplicates : SuperBlockCheckType::AllowDuplicates;
-
-
-    if (!m_chain_helper->mn_payments->IsBlockValueValid(m_chain, block, pindex->pprev, blockSubsidy + feeReward, strError, check_superblock)) {
+    if (!IsBlockValueValid(block, pindex, mnlist_updates.old_list, blockSubsidy + feeReward, strError)) {
         // NOTE: Do not punish, the node might be missing governance data
         LogPrintf("ERROR: ConnectBlock(DASH): %s\n", strError);
         return state.Invalid(BlockValidationResult::BLOCK_RESULT_UNSET, "bad-cb-amount");
@@ -2856,9 +3061,7 @@ bool Chainstate::ConnectBlock(const CBlock& block, BlockValidationState& state,
              Ticks<SecondsDouble>(time_value_valid),
              Ticks<MillisecondsDouble>(time_value_valid) / num_blocks_total);
 
-    const MnRewardEra mn_reward_era{GetMnRewardEraAfter(pindex->pprev, m_chainman)};
-    if (!m_chain_helper->mn_payments->IsBlockPayeeValid(m_chain, *block.vtx[0], pindex->pprev, blockSubsidy, feeReward,
-                                                        mn_reward_era, special_tx_rules.v24, check_superblock)) {
+    if (!IsBlockPayeeValid(block, pindex, mnlist_updates.old_list, blockSubsidy, feeReward)) {
         // NOTE: Do not punish, the node might be missing governance data
         LogPrintf("ERROR: ConnectBlock(DASH): couldn't find masternode or superblock payments\n");
         return state.Invalid(BlockValidationResult::BLOCK_RESULT_UNSET, "bad-cb-payee");
@@ -4690,7 +4893,7 @@ bool ChainstateManager::AcceptBlockHeader(const CBlockHeader& block, BlockValida
             }
         }
 
-        if (ActiveChainstate().m_chain_helper->HasConflictingChainLock(pindexPrev->nHeight + 1, hash)) {
+        if (ActiveChainstate().m_chainlocks.HasConflictingChainLock(pindexPrev->nHeight + 1, hash)) {
             if (miSelf == m_blockman.m_block_index.end()) {
                 m_blockman.AddToBlockIndex(block, hash, m_best_header, BLOCK_CONFLICT_CHAINLOCK);
             }
@@ -5181,8 +5384,6 @@ bool Chainstate::RollforwardBlock(const CBlockIndex* pindex, CCoinsViewCache& in
 {
     AssertLockHeld(cs_main);
 
-    assert(m_chain_helper);
-
     // TODO: merge with ConnectBlock
     CBlock block;
     if (!ReadBlockFromDisk(block, pindex,m_chainman.GetConsensus())) {
@@ -5194,7 +5395,7 @@ bool Chainstate::RollforwardBlock(const CBlockIndex* pindex, CCoinsViewCache& in
     BlockValidationState state;
     const CAmount blockSubsidy = GetBlockSubsidy(pindex, m_chainman.GetConsensus());
     MNListUpdates mnlist_updates;
-    if (!m_chain_helper->special_tx->ProcessSpecialTxsInBlock(*this, m_chain, block, pindex,
+    if (!m_special_tx.ProcessSpecialTxsInBlock(*this, m_chain, block, pindex,
                                                               GetSpecialTxRules(pindex->pprev, m_chainman), inputs,
                                                               blockSubsidy, /*fJustCheck=*/false,
                                                               /*fCheckCbTxMerkleRoots=*/false, state, mnlist_updates)) {
@@ -5944,14 +6145,16 @@ std::vector<Chainstate*> ChainstateManager::GetAll()
 
 Chainstate& ChainstateManager::InitializeChainstate(CTxMemPool* mempool,
                                                      CEvoDB& evoDb,
-                                                     const std::unique_ptr<CChainstateHelper>& chain_helper)
+                                                     CSpecialTxProcessor& special_tx,
+                                                     const chainlock::Chainlocks& chainlocks,
+                                                     llmq::CInstantSendManager* isman)
 {
     AssertLockHeld(::cs_main);
     assert(!m_ibd_chainstate);
     assert(!m_active_chainstate);
 
     m_ibd_chainstate = std::make_unique<Chainstate>(
-        mempool, m_blockman, *this, evoDb, chain_helper);
+        mempool, m_blockman, *this, evoDb, special_tx, chainlocks, isman);
     m_active_chainstate = m_ibd_chainstate.get();
     return *m_active_chainstate;
 }
@@ -6068,7 +6271,9 @@ bool ChainstateManager::ActivateSnapshot(
     auto snapshot_chainstate = WITH_LOCK(::cs_main, return std::make_unique<Chainstate>(
             /*mempool=*/ nullptr, m_blockman, *this,
             this->ActiveChainstate().m_evoDb,
-            this->ActiveChainstate().m_chain_helper,
+            this->ActiveChainstate().m_special_tx,
+            this->ActiveChainstate().m_chainlocks,
+            this->ActiveChainstate().m_isman,
             base_blockhash
         )
     );
@@ -6393,7 +6598,7 @@ bool ChainstateManager::PopulateAndValidateSnapshot(
     if (const CBlockIndex* ibd_tip = m_ibd_chainstate->m_chain.Tip();
         ibd_tip != nullptr && ibd_tip->GetBlockHash() == base_blockhash) {
         base_mn_list_hash =
-            snapshot_chainstate.ChainHelper().GetDeterministicMNListHash(snapshot_start_block);
+            snapshot_chainstate.m_special_tx.GetDeterministicMNListHash(snapshot_start_block);
         auto db_tx = snapshot_chainstate.m_evoDb.BeginTransaction(::EvoDbIdentity::NORMAL);
         snapshot_chainstate.m_evoDb.WriteBackgroundMNListHash(base_blockhash, *base_mn_list_hash);
         db_tx->Commit();
@@ -6845,7 +7050,9 @@ Chainstate* ChainstateManager::ActivateExistingSnapshot(CTxMemPool* mempool, uin
     m_snapshot_chainstate = std::make_unique<Chainstate>(
         mempool, m_blockman, *this,
         evo_db,
-        this->ActiveChainstate().m_chain_helper,
+        this->ActiveChainstate().m_special_tx,
+        this->ActiveChainstate().m_chainlocks,
+        this->ActiveChainstate().m_isman,
         base_blockhash);
     LogPrintf("[snapshot] switching active chainstate to %s\n", m_snapshot_chainstate->ToString());
     m_active_chainstate = m_snapshot_chainstate.get();
diff --git a/src/validation.h b/src/validation.h
index 2b6e8e6ce9f9..2c7b989553b5 100644
--- a/src/validation.h
+++ b/src/validation.h
@@ -47,13 +47,11 @@
 #include <vector>
 
 class Chainstate;
-class CBlockTreeDB;
 class CChainParams;
 class CEvoDB;
-class CMNHFManager;
 class CTxMemPool;
 class TxValidationState;
-class CChainstateHelper;
+class CSpecialTxProcessor;
 class CDeterministicMNList;
 class ChainstateManager;
 enum class EvoDbIdentity;
@@ -66,6 +64,9 @@ struct AssumeutxoData;
 namespace Consensus {
 struct Params;
 } // namespace Consensus
+namespace llmq {
+class CInstantSendManager;
+} // namespace llmq
 namespace node {
 class SnapshotMetadata;
 } // namespace node
@@ -131,6 +132,9 @@ CAmount GetBlockSubsidyInner(int nPrevBits, int nPrevHeight, const Consensus::Pa
 CAmount GetSuperblockSubsidyInner(int nPrevBits, int nPrevHeight, const Consensus::Params& consensusParams, bool fV20Active);
 CAmount GetBlockSubsidy(const CBlockIndex* const pindex, const Consensus::Params& consensusParams);
 
+/** The superblock share of all subsidies issued during the cycle ending at a superblock height. */
+CAmount GetSuperblockPaymentsLimit(int nBlockHeight, const Consensus::Params& consensusParams);
+
 bool AbortNode(BlockValidationState& state, const std::string& strMessage, const bilingual_str& userMessage = bilingual_str{});
 
 /** Guess verification progress (as a fraction between 0.0=genesis and 1.0=current tip). */
@@ -501,8 +505,6 @@ class Chainstate
     //! Manages the UTXO set, which is a reflection of the contents of `m_chain`.
     std::unique_ptr<CoinsViews> m_coins_views;
 
-    //! Dash
-    const std::unique_ptr<CChainstateHelper>& m_chain_helper;
     CEvoDB& m_evoDb;
 
     //! This toggle exists for use when doing background validation for UTXO
@@ -535,7 +537,9 @@ class Chainstate
                          node::BlockManager& blockman,
                          ChainstateManager& chainman,
                          CEvoDB& evoDb,
-                         const std::unique_ptr<CChainstateHelper>& chain_helper,
+                         CSpecialTxProcessor& special_tx,
+                         const chainlock::Chainlocks& chainlocks,
+                         llmq::CInstantSendManager* isman,
                          std::optional<uint256> from_snapshot_blockhash = std::nullopt);
 
     //! Return the stable EvoDB identity corresponding to this chainstate's coins DB.
@@ -593,11 +597,11 @@ class Chainstate
      */
     std::set<CBlockIndex*, node::CBlockIndexWorkComparator> setBlockIndexCandidates;
 
-    CChainstateHelper& ChainHelper()
-    {
-        assert(m_chain_helper);
-        return *m_chain_helper;
-    }
+    //! Dash: chainman-bound processors and managers used by block validation
+    CSpecialTxProcessor& m_special_tx;
+    const chainlock::Chainlocks& m_chainlocks;
+    //! Null when running without InstantSend (bitcoin-chainstate)
+    llmq::CInstantSendManager* const m_isman;
 
     //! @returns A reference to the in-memory cache of the UTXO set.
     CCoinsViewCache& CoinsTip() EXCLUSIVE_LOCKS_REQUIRED(::cs_main)
@@ -705,6 +709,12 @@ class Chainstate
     DisconnectResult DisconnectBlock(const CBlock& block, const CBlockIndex* pindex, CCoinsViewCache& view) EXCLUSIVE_LOCKS_REQUIRED(cs_main);
     bool ConnectBlock(const CBlock& block, BlockValidationState& state, CBlockIndex* pindex, CCoinsViewCache& view, bool fJustCheck = false) EXCLUSIVE_LOCKS_REQUIRED(cs_main);
 
+    /** Dash: the coinbase may pay out at most the block reward plus, on a
+     *  triggered superblock, the payments governance expects at that height. */
+    bool IsBlockValueValid(const CBlock& block, const CBlockIndex* pindex, const CDeterministicMNList& mn_list, CAmount blockReward, std::string& strErrorRet) const;
+    /** Dash: the coinbase must carry every payment owed to the masternode list at the previous block. */
+    bool IsBlockPayeeValid(const CBlock& block, const CBlockIndex* pindex, const CDeterministicMNList& mn_list, CAmount blockSubsidy, CAmount feeReward) const;
+
     // Apply the effects of a block disconnection on the UTXO set.
     bool DisconnectTip(BlockValidationState& state, DisconnectedBlockTransactions* disconnectpool) EXCLUSIVE_LOCKS_REQUIRED(cs_main, m_mempool->cs);
 
@@ -771,6 +781,10 @@ class Chainstate
         return m_mempool ? &m_mempool->cs : nullptr;
     }
 private:
+    //! Dash: superblock payments are only enforced by a synced node and for
+    //! blocks that are not chainlocked yet
+    bool IsSuperblockValidationRequired(const CBlockIndex* const pindex) const;
+
     bool ActivateBestChainStep(BlockValidationState& state, CBlockIndex* pindexMostWork, const std::shared_ptr<const CBlock>& pblock, bool& fInvalidFound, ConnectTrace& connectTrace) EXCLUSIVE_LOCKS_REQUIRED(cs_main, m_mempool->cs);
     bool ConnectTip(BlockValidationState& state, CBlockIndex* pindexNew, const std::shared_ptr<const CBlock>& pblock, ConnectTrace& connectTrace, DisconnectedBlockTransactions& disconnectpool) EXCLUSIVE_LOCKS_REQUIRED(cs_main, m_mempool->cs);
 
@@ -1047,7 +1061,9 @@ class ChainstateManager
     //                                  constructor
     Chainstate& InitializeChainstate(CTxMemPool* mempool,
                                       CEvoDB& evoDb,
-                                      const std::unique_ptr<CChainstateHelper>& chain_helper)
+                                      CSpecialTxProcessor& special_tx,
+                                      const chainlock::Chainlocks& chainlocks,
+                                      llmq::CInstantSendManager* isman)
         LIFETIMEBOUND EXCLUSIVE_LOCKS_REQUIRED(::cs_main);
 
     //! Get all chainstates currently being used.
diff --git a/test/lint/lint-circular-dependencies.py b/test/lint/lint-circular-dependencies.py
index 0a8df7b6e662..d77e213722c7 100755
--- a/test/lint/lint-circular-dependencies.py
+++ b/test/lint/lint-circular-dependencies.py
@@ -40,7 +40,6 @@
     "evo/assetlocktx -> llmq/commitment -> validation -> evo/assetlocktx",
     "evo/assetlocktx -> llmq/commitment -> validation -> txmempool -> evo/assetlocktx",
     "evo/cbtx -> llmq/blockprocessor -> validation -> evo/cbtx",
-    "evo/chainhelper -> evo/creditpool -> validation -> evo/chainhelper",
     "evo/creditpool -> validation -> evo/creditpool",
     "evo/creditpool -> validation -> evo/specialtxman -> evo/creditpool",
     "evo/deterministicmns -> node/blockstorage -> validation -> evo/deterministicmns",
@@ -48,7 +47,7 @@
     "evo/deterministicmns -> node/blockstorage -> validation -> txmempool -> evo/deterministicmns",
     "evo/smldiff -> llmq/blockprocessor -> llmq/utils -> llmq/snapshot -> evo/smldiff",
     "evo/specialtxman -> llmq/blockprocessor -> validation -> evo/specialtxman",
-    "governance/superblock -> validation -> masternode/payments -> governance/superblock",
+    "instantsend/instantsend -> node/blockstorage -> validation -> instantsend/instantsend",
     "instantsend/instantsend -> node/blockstorage -> validation -> txmempool -> instantsend/instantsend",
     "llmq/blockprocessor -> llmq/utils -> llmq/snapshot -> llmq/blockprocessor",
     "llmq/commitment -> llmq/utils -> llmq/snapshot -> llmq/commitment",