diff --git a/src/active/context.cpp b/src/active/context.cpp
index d025c61b6149..73b0aad40d75 100644
--- a/src/active/context.cpp
+++ b/src/active/context.cpp
@@ -24,14 +24,13 @@
 #include <validation.h>
 
 ActiveContext::ActiveContext(CBLSWorker& bls_worker, ChainstateManager& chainman, CConnman& connman,
-                             CDeterministicMNManager& dmnman, CGovernanceManager& govman,
-                             CMasternodeMetaMan& mn_metaman, CMNHFManager& mnhfman, CSporkManager& sporkman,
-                             CTxMemPool& mempool, llmq::CChainLocksHandler& clhandler, llmq::CInstantSendManager& isman,
-                             llmq::CQuorumBlockProcessor& qblockman, llmq::CQuorumManager& qman,
-                             llmq::CQuorumSnapshotManager& qsnapman, llmq::CSigningManager& sigman,
-                             PeerManager& peerman, const CMasternodeSync& mn_sync, const CBLSSecretKey& operator_sk,
-                             const llmq::QvvecSyncModeMap& sync_map, const util::DbWrapperParams& db_params,
-                             bool quorums_recovery, bool quorums_watch) :
+                             CDeterministicMNManager& dmnman, CGovernanceManager& govman, CMasternodeMetaMan& mn_metaman,
+                             CSporkManager& sporkman, CTxMemPool& mempool, llmq::CChainLocksHandler& clhandler,
+                             llmq::CInstantSendManager& isman, llmq::CQuorumBlockProcessor& qblockman,
+                             llmq::CQuorumManager& qman, llmq::CQuorumSnapshotManager& qsnapman,
+                             llmq::CSigningManager& sigman, PeerManager& peerman, const CMasternodeSync& mn_sync,
+                             const CBLSSecretKey& operator_sk, const llmq::QvvecSyncModeMap& sync_map,
+                             const util::DbWrapperParams& db_params, bool quorums_recovery, bool quorums_watch) :
     m_clhandler{clhandler},
     m_isman{isman},
     m_qman{qman},
@@ -41,7 +40,7 @@ ActiveContext::ActiveContext(CBLSWorker& bls_worker, ChainstateManager& chainman
     shareman{std::make_unique<llmq::CSigSharesManager>(connman, chainman.ActiveChainstate(), sigman, peerman, *nodeman,
                                                        qman, sporkman)},
     gov_signer{std::make_unique<GovernanceSigner>(connman, dmnman, govman, *nodeman, chainman, mn_sync)},
-    ehf_sighandler{std::make_unique<llmq::CEHFSignalsHandler>(chainman, mnhfman, sigman, *shareman, qman)},
+    ehf_sighandler{std::make_unique<llmq::CEHFSignalsHandler>(chainman, sigman, *shareman, qman)},
     qman_handler{std::make_unique<llmq::QuorumParticipant>(bls_worker, connman, dmnman, qman, qsnapman, *nodeman, chainman,
                                                            mn_sync, sporkman, sync_map, quorums_recovery, quorums_watch)},
     cl_signer{std::make_unique<chainlock::ChainLockSigner>(chainman.ActiveChainstate(), clhandler, sigman, *shareman,
diff --git a/src/active/context.h b/src/active/context.h
index c147ed7ea6ff..700f6f700db6 100644
--- a/src/active/context.h
+++ b/src/active/context.h
@@ -63,13 +63,12 @@ struct ActiveContext final : public CValidationInterface {
     ActiveContext& operator=(const ActiveContext&) = delete;
     explicit ActiveContext(CBLSWorker& bls_worker, ChainstateManager& chainman, CConnman& connman,
                            CDeterministicMNManager& dmnman, CGovernanceManager& govman, CMasternodeMetaMan& mn_metaman,
-                           CMNHFManager& mnhfman, CSporkManager& sporkman, CTxMemPool& mempool,
-                           llmq::CChainLocksHandler& clhandler, llmq::CInstantSendManager& isman,
-                           llmq::CQuorumBlockProcessor& qblockman, llmq::CQuorumManager& qman,
-                           llmq::CQuorumSnapshotManager& qsnapman, llmq::CSigningManager& sigman, PeerManager& peerman,
-                           const CMasternodeSync& mn_sync, const CBLSSecretKey& operator_sk,
-                           const llmq::QvvecSyncModeMap& sync_map, const util::DbWrapperParams& db_params,
-                           bool quorums_recovery, bool quorums_watch);
+                           CSporkManager& sporkman, CTxMemPool& mempool, llmq::CChainLocksHandler& clhandler,
+                           llmq::CInstantSendManager& isman, llmq::CQuorumBlockProcessor& qblockman,
+                           llmq::CQuorumManager& qman, llmq::CQuorumSnapshotManager& qsnapman,
+                           llmq::CSigningManager& sigman, PeerManager& peerman, const CMasternodeSync& mn_sync,
+                           const CBLSSecretKey& operator_sk, const llmq::QvvecSyncModeMap& sync_map,
+                           const util::DbWrapperParams& db_params, bool quorums_recovery, bool quorums_watch);
     ~ActiveContext();
 
     void Interrupt();
diff --git a/src/evo/chainhelper.cpp b/src/evo/chainhelper.cpp
index 9c11fc4e6a3c..4a2ac546e8b7 100644
--- a/src/evo/chainhelper.cpp
+++ b/src/evo/chainhelper.cpp
@@ -7,22 +7,26 @@
 #include <chainparams.h>
 
 #include <chainlock/chainlock.h>
+#include <evo/creditpool.h>
+#include <evo/mnhftx.h>
 #include <evo/specialtxman.h>
 #include <instantsend/instantsend.h>
 #include <instantsend/lock.h>
 #include <masternode/payments.h>
 
-CChainstateHelper::CChainstateHelper(CCreditPoolManager& cpoolman, CDeterministicMNManager& dmnman,
-                                     CMNHFManager& mnhfman, CGovernanceManager& govman, llmq::CInstantSendManager& isman,
-                                     llmq::CQuorumBlockProcessor& qblockman, llmq::CQuorumSnapshotManager& qsnapman,
-                                     const ChainstateManager& chainman, const Consensus::Params& consensus_params,
-                                     const CMasternodeSync& mn_sync, const CSporkManager& sporkman,
-                                     const llmq::CChainLocksHandler& clhandler, const llmq::CQuorumManager& qman) :
+CChainstateHelper::CChainstateHelper(CEvoDB& evodb, CDeterministicMNManager& dmnman, CGovernanceManager& govman,
+                                     llmq::CInstantSendManager& isman, llmq::CQuorumBlockProcessor& qblockman,
+                                     llmq::CQuorumSnapshotManager& qsnapman, const ChainstateManager& chainman,
+                                     const Consensus::Params& consensus_params, const CMasternodeSync& mn_sync,
+                                     const CSporkManager& sporkman, const llmq::CChainLocksHandler& clhandler,
+                                     const llmq::CQuorumManager& qman) :
     isman{isman},
     clhandler{clhandler},
+    ehf_manager{std::make_unique<CMNHFManager>(evodb, chainman, qman)},
+    credit_pool_manager{std::make_unique<CCreditPoolManager>(evodb, chainman)},
     mn_payments{std::make_unique<CMNPaymentsProcessor>(dmnman, govman, chainman, consensus_params, mn_sync, sporkman)},
-    special_tx{std::make_unique<CSpecialTxProcessor>(cpoolman, dmnman, mnhfman, qblockman, qsnapman, chainman,
-                                                     consensus_params, clhandler, qman)}
+    special_tx{std::make_unique<CSpecialTxProcessor>(*credit_pool_manager, dmnman, *ehf_manager, qblockman, qsnapman,
+                                                     chainman, consensus_params, clhandler, qman)}
 {}
 
 CChainstateHelper::~CChainstateHelper() = default;
@@ -61,3 +65,7 @@ bool CChainstateHelper::RemoveConflictingISLockByTx(const CTransaction& tx)
 
 bool CChainstateHelper::ShouldInstantSendRejectConflicts() const { return isman.RejectConflictingBlocks(); }
 
+std::unordered_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
index 66bee994652f..45dfcedc96d2 100644
--- a/src/evo/chainhelper.h
+++ b/src/evo/chainhelper.h
@@ -7,9 +7,12 @@
 
 #include <memory>
 #include <optional>
+#include <unordered_map>
 
+class CBlockIndex;
 class CCreditPoolManager;
 class CDeterministicMNManager;
+class CEvoDB;
 class ChainstateManager;
 class CMNHFManager;
 class CMNPaymentsProcessor;
@@ -39,12 +42,12 @@ class CChainstateHelper
     CChainstateHelper() = delete;
     CChainstateHelper(const CChainstateHelper&) = delete;
     CChainstateHelper& operator=(const CChainstateHelper&) = delete;
-    explicit CChainstateHelper(CCreditPoolManager& cpoolman, CDeterministicMNManager& dmnman, CMNHFManager& mnhfman,
-                               CGovernanceManager& govman, llmq::CInstantSendManager& isman,
-                               llmq::CQuorumBlockProcessor& qblockman, llmq::CQuorumSnapshotManager& qsnapman,
-                               const ChainstateManager& chainman, const Consensus::Params& consensus_params,
-                               const CMasternodeSync& mn_sync, const CSporkManager& sporkman,
-                               const llmq::CChainLocksHandler& clhandler, const llmq::CQuorumManager& qman);
+    explicit CChainstateHelper(CEvoDB& evodb, CDeterministicMNManager& dmnman, CGovernanceManager& govman,
+                               llmq::CInstantSendManager& isman, llmq::CQuorumBlockProcessor& qblockman,
+                               llmq::CQuorumSnapshotManager& qsnapman, const ChainstateManager& chainman,
+                               const Consensus::Params& consensus_params, const CMasternodeSync& mn_sync,
+                               const CSporkManager& sporkman, const llmq::CChainLocksHandler& clhandler,
+                               const llmq::CQuorumManager& qman);
     ~CChainstateHelper();
 
     /** Passthrough functions to CChainLocksHandler */
@@ -58,7 +61,11 @@ class CChainstateHelper
     bool RemoveConflictingISLockByTx(const CTransaction& tx);
     bool ShouldInstantSendRejectConflicts() const;
 
+    std::unordered_map<uint8_t, int> GetSignalsStage(const CBlockIndex* const pindexPrev);
+
 public:
+    const std::unique_ptr<CMNHFManager> ehf_manager;
+    const std::unique_ptr<CCreditPoolManager> credit_pool_manager;
     const std::unique_ptr<CMNPaymentsProcessor> mn_payments;
     const std::unique_ptr<CSpecialTxProcessor> special_tx;
 };
diff --git a/src/evo/deterministicmns.cpp b/src/evo/deterministicmns.cpp
index aa97f67de072..ac89530dc6ee 100644
--- a/src/evo/deterministicmns.cpp
+++ b/src/evo/deterministicmns.cpp
@@ -11,7 +11,6 @@
 #include <evo/simplifiedmns.h>
 #include <evo/specialtx.h>
 #include <masternode/meta.h>
-#include <messagesigner.h>
 #include <stats/client.h>
 #include <util/irange.h>
 #include <util/pointer.h>
@@ -24,7 +23,6 @@
 #include <node/blockstorage.h>
 #include <script/standard.h>
 #include <uint256.h>
-#include <validation.h>
 
 #include <functional>
 #include <optional>
@@ -944,472 +942,6 @@ void CDeterministicMNManager::CleanupCache(int nHeight)
 
 }
 
-template <typename ProTx>
-static bool CheckService(const ProTx& proTx, TxValidationState& state)
-{
-    switch (proTx.netInfo->Validate()) {
-    case NetInfoStatus::BadAddress:
-        return state.Invalid(TxValidationResult::TX_BAD_SPECIAL, "bad-protx-netinfo-addr");
-    case NetInfoStatus::BadPort:
-        return state.Invalid(TxValidationResult::TX_BAD_SPECIAL, "bad-protx-netinfo-port");
-    case NetInfoStatus::BadType:
-        return state.Invalid(TxValidationResult::TX_BAD_SPECIAL, "bad-protx-netinfo-addr-type");
-    case NetInfoStatus::NotRoutable:
-        return state.Invalid(TxValidationResult::TX_BAD_SPECIAL, "bad-protx-netinfo-addr-unroutable");
-    case NetInfoStatus::Malformed:
-        return state.Invalid(TxValidationResult::TX_BAD_SPECIAL, "bad-protx-netinfo-bad");
-    case NetInfoStatus::Success:
-        return true;
-    // Shouldn't be possible during self-checks
-    case NetInfoStatus::BadInput:
-    case NetInfoStatus::Duplicate:
-    case NetInfoStatus::MaxLimit:
-        assert(false);
-    } // no default case, so the compiler can warn about missing cases
-    assert(false);
-}
-
-template <typename ProTx>
-static bool CheckPlatformFields(const ProTx& proTx, bool is_extended_addr, TxValidationState& state)
-{
-    if (proTx.platformNodeID.IsNull()) {
-        return state.Invalid(TxValidationResult::TX_BAD_SPECIAL, "bad-protx-platform-nodeid");
-    }
-
-    if (is_extended_addr) {
-        // platformHTTPPort and platformP2PPort have been subsumed by netInfo. They should always be zero.
-        if (proTx.platformP2PPort != 0) {
-            return state.Invalid(TxValidationResult::TX_BAD_SPECIAL, "bad-protx-platform-p2p-port");
-        }
-        if (proTx.platformHTTPPort != 0) {
-            return state.Invalid(TxValidationResult::TX_BAD_SPECIAL, "bad-protx-platform-http-port");
-        }
-        return true;
-    }
-
-    if (::IsNodeOnMainnet()) {
-        if (proTx.platformP2PPort != ::MainParams().GetDefaultPlatformP2PPort()) {
-            return state.Invalid(TxValidationResult::TX_BAD_SPECIAL, "bad-protx-platform-p2p-port");
-        }
-        if (proTx.platformHTTPPort != ::MainParams().GetDefaultPlatformHTTPPort()) {
-            return state.Invalid(TxValidationResult::TX_BAD_SPECIAL, "bad-protx-platform-http-port");
-        }
-    }
-    if (proTx.platformP2PPort == ::MainParams().GetDefaultPort()) {
-        return state.Invalid(TxValidationResult::TX_BAD_SPECIAL, "bad-protx-platform-p2p-port");
-    }
-    if (proTx.platformHTTPPort == ::MainParams().GetDefaultPort()) {
-        return state.Invalid(TxValidationResult::TX_BAD_SPECIAL, "bad-protx-platform-http-port");
-    }
-
-    const uint16_t core_port{proTx.netInfo->GetPrimary().GetPort()};
-    if (proTx.platformP2PPort == proTx.platformHTTPPort || proTx.platformP2PPort == core_port ||
-        proTx.platformHTTPPort == core_port) {
-        return state.Invalid(TxValidationResult::TX_BAD_SPECIAL, "bad-protx-platform-dup-ports");
-    }
-
-    return true;
-}
-
-template <typename ProTx>
-static bool CheckHashSig(const ProTx& proTx, const PKHash& pkhash, TxValidationState& state)
-{
-    if (std::string strError; !CHashSigner::VerifyHash(::SerializeHash(proTx), ToKeyID(pkhash), proTx.vchSig, strError)) {
-        return state.Invalid(TxValidationResult::TX_CONSENSUS, "bad-protx-sig");
-    }
-    return true;
-}
-
-template <typename ProTx>
-static bool CheckStringSig(const ProTx& proTx, const PKHash& pkhash, TxValidationState& state)
-{
-    if (std::string strError; !CMessageSigner::VerifyMessage(ToKeyID(pkhash), proTx.vchSig, proTx.MakeSignString(), strError)) {
-        return state.Invalid(TxValidationResult::TX_CONSENSUS, "bad-protx-sig");
-    }
-    return true;
-}
-
-template <typename ProTx>
-static bool CheckHashSig(const ProTx& proTx, const CBLSPublicKey& pubKey, TxValidationState& state)
-{
-    if (!proTx.sig.VerifyInsecure(pubKey, ::SerializeHash(proTx))) {
-        return state.Invalid(TxValidationResult::TX_CONSENSUS, "bad-protx-sig");
-    }
-    return true;
-}
-
-template <typename ProTx>
-static std::optional<ProTx> GetValidatedPayload(const CTransaction& tx, gsl::not_null<const CBlockIndex*> pindexPrev,
-                                                const ChainstateManager& chainman, TxValidationState& state)
-{
-    if (tx.nType != ProTx::SPECIALTX_TYPE) {
-        state.Invalid(TxValidationResult::TX_CONSENSUS, "bad-protx-type");
-        return std::nullopt;
-    }
-
-    auto opt_ptx = GetTxPayload<ProTx>(tx);
-    if (!opt_ptx) {
-        state.Invalid(TxValidationResult::TX_CONSENSUS, "bad-protx-payload");
-        return std::nullopt;
-    }
-    if (!opt_ptx->IsTriviallyValid(pindexPrev, chainman, state)) {
-        // pass the state returned by the function above
-        return std::nullopt;
-    }
-    return opt_ptx;
-}
-
-/**
- * Validates potential changes to masternode state version by ProTx transaction version
- * @param[in]  pindexPrev    Previous block index to validate DEPLOYMENT_V24 activation
- * @param[in]  tx_type       Special transaction type
- * @param[in]  state_version Current masternode state version
- * @param[in]  tx_version    Proposed transaction version
- * @param[out] state         This may be set to an Error state if any error occurred processing them
- * @returns                  true if version change is valid or DEPLOYMENT_V24 is not active
- */
-bool IsVersionChangeValid(gsl::not_null<const CBlockIndex*> pindexPrev, const uint16_t tx_type,
-                          const uint16_t state_version, const uint16_t tx_version, const ChainstateManager& chainman,
-                          TxValidationState& state)
-{
-    if (!DeploymentActiveAfter(pindexPrev, chainman, Consensus::DEPLOYMENT_V24)) {
-        // New restrictions only apply after v24 deployment
-        return true;
-    }
-
-    if (state_version >= ProTxVersion::BasicBLS && tx_version == ProTxVersion::LegacyBLS) {
-        // Don't allow legacy scheme versioned transactions after upgrading to basic scheme
-        return state.Invalid(TxValidationResult::TX_CONSENSUS, "bad-protx-version-downgrade");
-    }
-
-    if (state_version == ProTxVersion::LegacyBLS && tx_version > ProTxVersion::BasicBLS) {
-        // Nodes using the legacy scheme must first upgrade to the basic scheme before upgrading further
-        return state.Invalid(TxValidationResult::TX_CONSENSUS, "bad-protx-version-upgrade");
-    }
-
-    if (tx_type != TRANSACTION_PROVIDER_UPDATE_SERVICE && tx_version == ProTxVersion::ExtAddr) {
-        // Only new entries (ProRegTx) and service updates (ProUpServTx) can use ExtAddr versioning
-        return state.Invalid(TxValidationResult::TX_CONSENSUS, "bad-protx-version-tx-type");
-    }
-
-    return true;
-}
-
-bool CheckProRegTx(const CTransaction& tx, gsl::not_null<const CBlockIndex*> pindexPrev,
-                   CDeterministicMNManager& dmnman, const CCoinsViewCache& view, const ChainstateManager& chainman,
-                   TxValidationState& state, bool check_sigs)
-{
-    const auto opt_ptx = GetValidatedPayload<CProRegTx>(tx, pindexPrev, chainman, state);
-    if (!opt_ptx) {
-        // pass the state returned by the function above
-        return false;
-    }
-
-    const bool is_v24_active{DeploymentActiveAfter(pindexPrev, chainman, Consensus::DEPLOYMENT_V24)};
-
-    // No longer allow legacy scheme masternode registration
-    if (is_v24_active && opt_ptx->nVersion < ProTxVersion::BasicBLS) {
-        return state.Invalid(TxValidationResult::TX_CONSENSUS, "bad-protx-version-disallowed");
-    }
-
-    // It's allowed to set addr to 0, which will put the MN into PoSe-banned state and require a ProUpServTx to be issues later
-    // If any of both is set, it must be valid however
-    if (!opt_ptx->netInfo->IsEmpty() && !CheckService(*opt_ptx, state)) {
-        // pass the state returned by the function above
-        return false;
-    }
-
-    if (opt_ptx->nType == MnType::Evo) {
-        if (!CheckPlatformFields(*opt_ptx, opt_ptx->nVersion >= ProTxVersion::ExtAddr, state)) {
-            return false;
-        }
-    }
-
-    CTxDestination collateralTxDest;
-    const PKHash *keyForPayloadSig = nullptr;
-    COutPoint collateralOutpoint;
-
-    CAmount expectedCollateral = GetMnType(opt_ptx->nType).collat_amount;
-
-    if (!opt_ptx->collateralOutpoint.hash.IsNull()) {
-        Coin coin;
-        if (!view.GetCoin(opt_ptx->collateralOutpoint, coin) || coin.IsSpent() || coin.out.nValue != expectedCollateral) {
-            return state.Invalid(TxValidationResult::TX_BAD_SPECIAL, "bad-protx-collateral");
-        }
-
-        if (!ExtractDestination(coin.out.scriptPubKey, collateralTxDest)) {
-            return state.Invalid(TxValidationResult::TX_BAD_SPECIAL, "bad-protx-collateral-dest");
-        }
-
-        // Extract key from collateral. This only works for P2PK and P2PKH collaterals and will fail for P2SH.
-        // Issuer of this ProRegTx must prove ownership with this key by signing the ProRegTx
-        keyForPayloadSig = std::get_if<PKHash>(&collateralTxDest);
-        if (!keyForPayloadSig) {
-            return state.Invalid(TxValidationResult::TX_BAD_SPECIAL, "bad-protx-collateral-pkh");
-        }
-
-        collateralOutpoint = opt_ptx->collateralOutpoint;
-    } else {
-        if (opt_ptx->collateralOutpoint.n >= tx.vout.size()) {
-            return state.Invalid(TxValidationResult::TX_BAD_SPECIAL, "bad-protx-collateral-index");
-        }
-        if (tx.vout[opt_ptx->collateralOutpoint.n].nValue != expectedCollateral) {
-            return state.Invalid(TxValidationResult::TX_BAD_SPECIAL, "bad-protx-collateral");
-        }
-
-        if (!ExtractDestination(tx.vout[opt_ptx->collateralOutpoint.n].scriptPubKey, collateralTxDest)) {
-            return state.Invalid(TxValidationResult::TX_BAD_SPECIAL, "bad-protx-collateral-dest");
-        }
-
-        collateralOutpoint = COutPoint(tx.GetHash(), opt_ptx->collateralOutpoint.n);
-    }
-
-    // don't allow reuse of collateral key for other keys (don't allow people to put the collateral key onto an online server)
-    // this check applies to internal and external collateral, but internal collaterals are not necessarily a P2PKH
-    if (collateralTxDest == CTxDestination(PKHash(opt_ptx->keyIDOwner)) || collateralTxDest == CTxDestination(PKHash(opt_ptx->keyIDVoting))) {
-        return state.Invalid(TxValidationResult::TX_BAD_SPECIAL, "bad-protx-collateral-reuse");
-    }
-
-    if (pindexPrev) {
-        auto mnList = dmnman.GetListForBlock(pindexPrev);
-
-        // only allow reusing of addresses when it's for the same collateral (which replaces the old MN)
-        for (const auto& entry : opt_ptx->netInfo->GetEntries()) {
-            if (const auto service_opt{entry.GetAddrPort()}) {
-                if (mnList.HasUniqueProperty(*service_opt) &&
-                    mnList.GetUniquePropertyMN(*service_opt)->collateralOutpoint != collateralOutpoint) {
-                    return state.Invalid(TxValidationResult::TX_BAD_SPECIAL, "bad-protx-dup-netinfo-entry");
-                }
-            } else if (const auto domain_opt{entry.GetDomainPort()}) {
-                if (mnList.HasUniqueProperty(*domain_opt) &&
-                    mnList.GetUniquePropertyMN(*domain_opt)->collateralOutpoint != collateralOutpoint) {
-                    return state.Invalid(TxValidationResult::TX_BAD_SPECIAL, "bad-protx-dup-netinfo-entry");
-                }
-            } else {
-                return state.Invalid(TxValidationResult::TX_BAD_SPECIAL, "bad-protx-netinfo-entry");
-            }
-        }
-
-        // never allow duplicate keys, even if this ProTx would replace an existing MN
-        if (mnList.HasUniqueProperty(opt_ptx->keyIDOwner) || mnList.HasUniqueProperty(opt_ptx->pubKeyOperator)) {
-            return state.Invalid(TxValidationResult::TX_BAD_SPECIAL, "bad-protx-dup-key");
-        }
-
-        // never allow duplicate platformNodeIds for EvoNodes
-        if (opt_ptx->nType == MnType::Evo) {
-            if (mnList.HasUniqueProperty(opt_ptx->platformNodeID)) {
-                return state.Invalid(TxValidationResult::TX_BAD_SPECIAL, "bad-protx-dup-platformnodeid");
-            }
-        }
-
-        if (!DeploymentDIP0003Enforced(pindexPrev->nHeight, Params().GetConsensus())) {
-            if (opt_ptx->keyIDOwner != opt_ptx->keyIDVoting) {
-                return state.Invalid(TxValidationResult::TX_BAD_SPECIAL, "bad-protx-key-not-same");
-            }
-        }
-    }
-
-    if (!CheckInputsHash(tx, *opt_ptx, state)) {
-        // pass the state returned by the function above
-        return false;
-    }
-
-    if (keyForPayloadSig) {
-        // collateral is not part of this ProRegTx, so we must verify ownership of the collateral
-        if (check_sigs && !CheckStringSig(*opt_ptx, *keyForPayloadSig, state)) {
-            // pass the state returned by the function above
-            return false;
-        }
-    } else {
-        // collateral is part of this ProRegTx, so we know the collateral is owned by the issuer
-        if (!opt_ptx->vchSig.empty()) {
-            return state.Invalid(TxValidationResult::TX_CONSENSUS, "bad-protx-sig");
-        }
-    }
-
-    return true;
-}
-
-bool CheckProUpServTx(const CTransaction& tx, gsl::not_null<const CBlockIndex*> pindexPrev, CDeterministicMNManager& dmnman,
-                      const ChainstateManager& chainman, TxValidationState& state, bool check_sigs)
-{
-    const auto opt_ptx = GetValidatedPayload<CProUpServTx>(tx, pindexPrev, chainman, state);
-    if (!opt_ptx) {
-        // pass the state returned by the function above
-        return false;
-    }
-
-    if (!CheckService(*opt_ptx, state)) {
-        // pass the state returned by the function above
-        return false;
-    }
-
-    if (opt_ptx->nType == MnType::Evo) {
-        if (!CheckPlatformFields(*opt_ptx, opt_ptx->nVersion >= ProTxVersion::ExtAddr, state)) {
-            return false;
-        }
-    }
-
-    auto mnList = dmnman.GetListForBlock(pindexPrev);
-    auto dmn = mnList.GetMN(opt_ptx->proTxHash);
-    if (!dmn) {
-        return state.Invalid(TxValidationResult::TX_CONSENSUS, "bad-protx-hash");
-    }
-
-    if (!IsVersionChangeValid(pindexPrev, tx.nType, dmn->pdmnState->nVersion, opt_ptx->nVersion, chainman, state)) {
-        // pass the state returned by the function above
-        return false;
-    }
-
-    // don't allow updating to addresses already used by other MNs
-    for (const auto& entry : opt_ptx->netInfo->GetEntries()) {
-        if (const auto service_opt{entry.GetAddrPort()}) {
-            if (mnList.HasUniqueProperty(*service_opt) &&
-                mnList.GetUniquePropertyMN(*service_opt)->proTxHash != opt_ptx->proTxHash) {
-                return state.Invalid(TxValidationResult::TX_BAD_SPECIAL, "bad-protx-dup-netinfo-entry");
-            }
-        } else if (const auto domain_opt{entry.GetDomainPort()}) {
-            if (mnList.HasUniqueProperty(*domain_opt) && mnList.GetUniquePropertyMN(*domain_opt)->proTxHash != opt_ptx->proTxHash) {
-                return state.Invalid(TxValidationResult::TX_BAD_SPECIAL, "bad-protx-dup-netinfo-entry");
-            }
-        } else {
-            return state.Invalid(TxValidationResult::TX_BAD_SPECIAL, "bad-protx-netinfo-entry");
-        }
-    }
-
-    // don't allow updating to platformNodeIds already used by other EvoNodes
-    if (opt_ptx->nType == MnType::Evo) {
-        if (mnList.HasUniqueProperty(opt_ptx->platformNodeID)  && mnList.GetUniquePropertyMN(opt_ptx->platformNodeID)->proTxHash != opt_ptx->proTxHash) {
-            return state.Invalid(TxValidationResult::TX_BAD_SPECIAL, "bad-protx-dup-platformnodeid");
-        }
-    }
-
-    if (opt_ptx->scriptOperatorPayout != CScript()) {
-        if (dmn->nOperatorReward == 0) {
-            // don't allow setting operator reward payee in case no operatorReward was set
-            return state.Invalid(TxValidationResult::TX_BAD_SPECIAL, "bad-protx-operator-payee");
-        }
-        if (!opt_ptx->scriptOperatorPayout.IsPayToPublicKeyHash() && !opt_ptx->scriptOperatorPayout.IsPayToScriptHash()) {
-            return state.Invalid(TxValidationResult::TX_BAD_SPECIAL, "bad-protx-operator-payee");
-        }
-    }
-
-    // we can only check the signature if pindexPrev != nullptr and the MN is known
-    if (!CheckInputsHash(tx, *opt_ptx, state)) {
-        // pass the state returned by the function above
-        return false;
-    }
-    if (check_sigs && !CheckHashSig(*opt_ptx, dmn->pdmnState->pubKeyOperator.Get(), state)) {
-        // pass the state returned by the function above
-        return false;
-    }
-
-    return true;
-}
-
-bool CheckProUpRegTx(const CTransaction& tx, gsl::not_null<const CBlockIndex*> pindexPrev,
-                     CDeterministicMNManager& dmnman, const CCoinsViewCache& view, const ChainstateManager& chainman,
-                     TxValidationState& state, bool check_sigs)
-{
-    const auto opt_ptx = GetValidatedPayload<CProUpRegTx>(tx, pindexPrev, chainman, state);
-    if (!opt_ptx) {
-        // pass the state returned by the function above
-        return false;
-    }
-
-    CTxDestination payoutDest;
-    if (!ExtractDestination(opt_ptx->scriptPayout, payoutDest)) {
-        // should not happen as we checked script types before
-        return state.Invalid(TxValidationResult::TX_BAD_SPECIAL, "bad-protx-payee-dest");
-    }
-
-    auto mnList = dmnman.GetListForBlock(pindexPrev);
-    auto dmn = mnList.GetMN(opt_ptx->proTxHash);
-    if (!dmn) {
-        return state.Invalid(TxValidationResult::TX_CONSENSUS, "bad-protx-hash");
-    }
-
-    if (!IsVersionChangeValid(pindexPrev, tx.nType, dmn->pdmnState->nVersion, opt_ptx->nVersion, chainman, state)) {
-        // pass the state returned by the function above
-        return false;
-    }
-
-    // don't allow reuse of payee key for other keys (don't allow people to put the payee key onto an online server)
-    if (payoutDest == CTxDestination(PKHash(dmn->pdmnState->keyIDOwner)) || payoutDest == CTxDestination(PKHash(opt_ptx->keyIDVoting))) {
-        return state.Invalid(TxValidationResult::TX_BAD_SPECIAL, "bad-protx-payee-reuse");
-    }
-
-    Coin coin;
-    if (!view.GetCoin(dmn->collateralOutpoint, coin) || coin.IsSpent()) {
-        // this should never happen (there would be no dmn otherwise)
-        return state.Invalid(TxValidationResult::TX_CONSENSUS, "bad-protx-collateral");
-    }
-
-    // don't allow reuse of collateral key for other keys (don't allow people to put the collateral key onto an online server)
-    CTxDestination collateralTxDest;
-    if (!ExtractDestination(coin.out.scriptPubKey, collateralTxDest)) {
-        return state.Invalid(TxValidationResult::TX_CONSENSUS, "bad-protx-collateral-dest");
-    }
-    if (collateralTxDest == CTxDestination(PKHash(dmn->pdmnState->keyIDOwner)) || collateralTxDest == CTxDestination(PKHash(opt_ptx->keyIDVoting))) {
-        return state.Invalid(TxValidationResult::TX_BAD_SPECIAL, "bad-protx-collateral-reuse");
-    }
-
-    if (mnList.HasUniqueProperty(opt_ptx->pubKeyOperator)) {
-        auto otherDmn = mnList.GetUniquePropertyMN(opt_ptx->pubKeyOperator);
-        if (opt_ptx->proTxHash != otherDmn->proTxHash) {
-            return state.Invalid(TxValidationResult::TX_BAD_SPECIAL, "bad-protx-dup-key");
-        }
-    }
-
-    if (!DeploymentDIP0003Enforced(pindexPrev->nHeight, Params().GetConsensus())) {
-        if (dmn->pdmnState->keyIDOwner != opt_ptx->keyIDVoting) {
-            return state.Invalid(TxValidationResult::TX_BAD_SPECIAL, "bad-protx-key-not-same");
-        }
-    }
-
-    if (!CheckInputsHash(tx, *opt_ptx, state)) {
-        // pass the state returned by the function above
-        return false;
-    }
-    if (check_sigs && !CheckHashSig(*opt_ptx, PKHash(dmn->pdmnState->keyIDOwner), state)) {
-        // pass the state returned by the function above
-        return false;
-    }
-
-    return true;
-}
-
-bool CheckProUpRevTx(const CTransaction& tx, gsl::not_null<const CBlockIndex*> pindexPrev, CDeterministicMNManager& dmnman,
-                     const ChainstateManager& chainman, TxValidationState& state, bool check_sigs)
-{
-    const auto opt_ptx = GetValidatedPayload<CProUpRevTx>(tx, pindexPrev, chainman, state);
-    if (!opt_ptx) {
-        // pass the state returned by the function above
-        return false;
-    }
-
-    auto mnList = dmnman.GetListForBlock(pindexPrev);
-    auto dmn = mnList.GetMN(opt_ptx->proTxHash);
-    if (!dmn) {
-        return state.Invalid(TxValidationResult::TX_CONSENSUS, "bad-protx-hash");
-    }
-
-    if (!IsVersionChangeValid(pindexPrev, tx.nType, dmn->pdmnState->nVersion, opt_ptx->nVersion, chainman, state)) {
-        // pass the state returned by the function above
-        return false;
-    }
-
-    if (!CheckInputsHash(tx, *opt_ptx, state)) {
-        // pass the state returned by the function above
-        return false;
-    }
-    if (check_sigs && !CheckHashSig(*opt_ptx, dmn->pdmnState->pubKeyOperator.Get(), state)) {
-        // pass the state returned by the function above
-        return false;
-    }
-
-    return true;
-}
 //end
 
 void CDeterministicMNManager::DoMaintenance() {
diff --git a/src/evo/deterministicmns.h b/src/evo/deterministicmns.h
index 1bdcf7343e96..006bc92b2892 100644
--- a/src/evo/deterministicmns.h
+++ b/src/evo/deterministicmns.h
@@ -35,9 +35,7 @@ class CEvoDB;
 class CSimplifiedMNList;
 class CSimplifiedMNListEntry;
 class CMasternodeMetaMan;
-class ChainstateManager;
 class CSpecialTxProcessor;
-class TxValidationState;
 struct RPCResult;
 
 extern RecursiveMutex cs_main;
@@ -766,16 +764,4 @@ class CDeterministicMNManager
     void WriteRepairedDiffs(const std::vector<std::pair<uint256, CDeterministicMNListDiff>>& recalculated_diffs,
                             RecalcDiffsResult& result) EXCLUSIVE_LOCKS_REQUIRED(!cs);
 };
-
-bool CheckProRegTx(const CTransaction& tx, gsl::not_null<const CBlockIndex*> pindexPrev,
-                   CDeterministicMNManager& dmnman, const CCoinsViewCache& view, const ChainstateManager& chainman,
-                   TxValidationState& state, bool check_sigs);
-bool CheckProUpServTx(const CTransaction& tx, gsl::not_null<const CBlockIndex*> pindexPrev, CDeterministicMNManager& dmnman,
-                      const ChainstateManager& chainman, TxValidationState& state, bool check_sigs);
-bool CheckProUpRegTx(const CTransaction& tx, gsl::not_null<const CBlockIndex*> pindexPrev,
-                     CDeterministicMNManager& dmnman, const CCoinsViewCache& view, const ChainstateManager& chainman,
-                     TxValidationState& state, bool check_sigs);
-bool CheckProUpRevTx(const CTransaction& tx, gsl::not_null<const CBlockIndex*> pindexPrev, CDeterministicMNManager& dmnman,
-                     const ChainstateManager& chainman, TxValidationState& state, bool check_sigs);
-
 #endif // BITCOIN_EVO_DETERMINISTICMNS_H
diff --git a/src/evo/mnhftx.cpp b/src/evo/mnhftx.cpp
index 8f4fa535c4f1..9c9db691acae 100644
--- a/src/evo/mnhftx.cpp
+++ b/src/evo/mnhftx.cpp
@@ -43,9 +43,10 @@ CMutableTransaction MNHFTxPayload::PrepareTx() const
     return tx;
 }
 
-CMNHFManager::CMNHFManager(CEvoDB& evoDb, const ChainstateManager& chainman) :
+CMNHFManager::CMNHFManager(CEvoDB& evoDb, const ChainstateManager& chainman, const llmq::CQuorumManager& qman) :
     m_evoDb(evoDb),
-    m_chainman{chainman}
+    m_chainman{chainman},
+    m_qman{qman}
 {
     assert(globalInstance == nullptr);
     globalInstance = this;
@@ -202,11 +203,9 @@ static bool extractSignals(const ChainstateManager& chainman, const llmq::CQuoru
 
 std::optional<CMNHFManager::Signals> CMNHFManager::ProcessBlock(const CBlock& block, const CBlockIndex* const pindex, bool fJustCheck, BlockValidationState& state)
 {
-    auto qman = Assert(m_qman.load(std::memory_order_acquire));
-
     try {
         std::vector<uint8_t> new_signals;
-        if (!extractSignals(m_chainman, *qman, block, pindex, new_signals, state)) {
+        if (!extractSignals(m_chainman, m_qman, block, pindex, new_signals, state)) {
             // state is set inside extractSignals
             return std::nullopt;
         }
@@ -253,11 +252,9 @@ std::optional<CMNHFManager::Signals> CMNHFManager::ProcessBlock(const CBlock& bl
 
 bool CMNHFManager::UndoBlock(const CBlock& block, const CBlockIndex* const pindex)
 {
-    auto qman = Assert(m_qman.load(std::memory_order_acquire));
-
     std::vector<uint8_t> excluded_signals;
     BlockValidationState state;
-    if (!extractSignals(m_chainman, *qman, block, pindex, excluded_signals, state)) {
+    if (!extractSignals(m_chainman, m_qman, block, pindex, excluded_signals, state)) {
         LogPrintf("CMNHFManager::%s: failed to extract signals\n", __func__);
         return false;
     }
@@ -370,18 +367,6 @@ void CMNHFManager::AddSignal(const CBlockIndex* const pindex, int bit)
     AddToCache(signals, pindex);
 }
 
-void CMNHFManager::ConnectManagers(gsl::not_null<llmq::CQuorumManager*> qman)
-{
-    // Do not allow double-initialization
-    assert(m_qman.load(std::memory_order_acquire) == nullptr);
-    m_qman.store(qman, std::memory_order_release);
-}
-
-void CMNHFManager::DisconnectManagers()
-{
-    m_qman.store(nullptr, std::memory_order_release);
-}
-
 bool CMNHFManager::ForceSignalDBUpdate()
 {
     // force ehf signals db update
diff --git a/src/evo/mnhftx.h b/src/evo/mnhftx.h
index 2f399412c24c..db4541d0cc2c 100644
--- a/src/evo/mnhftx.h
+++ b/src/evo/mnhftx.h
@@ -16,7 +16,6 @@
 #include <gsl/pointers.h>
 #include <univalue.h>
 
-#include <atomic>
 #include <optional>
 
 class BlockValidationState;
@@ -90,8 +89,13 @@ class CMNHFManager : public AbstractEHFManager
 {
 private:
     CEvoDB& m_evoDb;
+    // TODO: move its functionallity of ProcessBlock, UndoBlock to specialtxman;
+    // it will help to drop dependency on m_chainman, m_qman here (and validation.h)
+    // Secondly, store in database active EHF signals not for each block;
+    // but quite opposite: keep only hash of block where signal is added.
+    // TODO: implement migration to a new format
     const ChainstateManager& m_chainman;
-    std::atomic<llmq::CQuorumManager*> m_qman{nullptr};
+    const llmq::CQuorumManager& m_qman;
 
     static constexpr size_t MNHFCacheSize = 1000;
     Mutex cs_cache;
@@ -102,15 +106,12 @@ class CMNHFManager : public AbstractEHFManager
     CMNHFManager() = delete;
     CMNHFManager(const CMNHFManager&) = delete;
     CMNHFManager& operator=(const CMNHFManager&) = delete;
-    explicit CMNHFManager(CEvoDB& evoDb, const ChainstateManager& chainman);
+    explicit CMNHFManager(CEvoDB& evoDb, const ChainstateManager& chainman, const llmq::CQuorumManager& qman);
     ~CMNHFManager();
 
     /**
      * Every new block should be processed when Tip() is updated by calling of CMNHFManager::ProcessBlock.
      * This function actually does only validate EHF transaction for this block and update internal caches/evodb state
-     *
-     * @pre Caller must ensure that LLMQContext has been initialized and the llmq::CQuorumManager pointer has been
-     *      set by calling ConnectManagers() for this CMNHFManager instance
      */
     std::optional<Signals> ProcessBlock(const CBlock& block, const CBlockIndex* const pindex, bool fJustCheck,
                                         BlockValidationState& state) EXCLUSIVE_LOCKS_REQUIRED(!cs_cache);
@@ -119,9 +120,6 @@ class CMNHFManager : public AbstractEHFManager
      * Every undo block should be processed when Tip() is updated by calling of CMNHFManager::UndoBlock
      * This function actually does nothing at the moment, because status of ancestor block is already known.
      * Although it should be still called to do some sanity checks
-     *
-     * @pre Caller must ensure that LLMQContext has been initialized and the llmq::CQuorumManager pointer has been
-     *      set by calling ConnectManagers() for this CMNHFManager instance
      */
     bool UndoBlock(const CBlock& block, const CBlockIndex* const pindex) EXCLUSIVE_LOCKS_REQUIRED(!cs_cache);
 
@@ -133,21 +131,6 @@ class CMNHFManager : public AbstractEHFManager
      */
     void AddSignal(const CBlockIndex* const pindex, int bit) EXCLUSIVE_LOCKS_REQUIRED(!cs_cache);
 
-    /**
-     * Set llmq::CQuorumManager pointer.
-     *
-     * Separated from constructor to allow LLMQContext to use CMNHFManager in read-only capacity.
-     * Required to mutate state.
-     */
-    void ConnectManagers(gsl::not_null<llmq::CQuorumManager*> qman);
-
-    /**
-     * Reset llmq::CQuorumManager pointer.
-     *
-     * @pre Must be called before LLMQContext (containing llmq::CQuorumManager) is destroyed.
-     */
-    void DisconnectManagers();
-
     bool ForceSignalDBUpdate() EXCLUSIVE_LOCKS_REQUIRED(::cs_main, !cs_cache);
 
 private:
diff --git a/src/evo/specialtxman.cpp b/src/evo/specialtxman.cpp
index 3cdb9e7e79d8..d00dd35791d1 100644
--- a/src/evo/specialtxman.cpp
+++ b/src/evo/specialtxman.cpp
@@ -4,28 +4,29 @@
 
 #include <evo/specialtxman.h>
 
+#include <chainlock/chainlock.h>
+#include <chainlock/clsig.h>
 #include <chainparams.h>
 #include <consensus/amount.h>
 #include <consensus/validation.h>
 #include <deploymentstatus.h>
-#include <hash.h>
-#include <primitives/block.h>
-#include <util/irange.h>
-#include <util/system.h>
-#include <validation.h>
-
-#include <chainlock/chainlock.h>
-#include <chainlock/clsig.h>
 #include <evo/assetlocktx.h>
 #include <evo/cbtx.h>
 #include <evo/creditpool.h>
 #include <evo/deterministicmns.h>
 #include <evo/mnhftx.h>
+#include <evo/netinfo.h>
 #include <evo/simplifiedmns.h>
+#include <hash.h>
 #include <llmq/blockprocessor.h>
 #include <llmq/commitment.h>
 #include <llmq/quorumsman.h>
 #include <llmq/utils.h>
+#include <messagesigner.h>
+#include <primitives/block.h>
+#include <util/irange.h>
+#include <util/system.h>
+#include <validation.h>
 
 static bool CheckCbTxBestChainlock(const CCbTx& cbTx, const CBlockIndex* pindex,
                                    const llmq::CChainLocksHandler& chainlock_handler, BlockValidationState& state)
@@ -757,3 +758,476 @@ bool CSpecialTxProcessor::CheckCreditPoolDiffForBlock(const CBlock& block, const
 
     return true;
 }
+
+template <typename ProTx>
+static bool CheckService(const ProTx& proTx, TxValidationState& state)
+{
+    switch (proTx.netInfo->Validate()) {
+    case NetInfoStatus::BadAddress:
+        return state.Invalid(TxValidationResult::TX_BAD_SPECIAL, "bad-protx-netinfo-addr");
+    case NetInfoStatus::BadPort:
+        return state.Invalid(TxValidationResult::TX_BAD_SPECIAL, "bad-protx-netinfo-port");
+    case NetInfoStatus::BadType:
+        return state.Invalid(TxValidationResult::TX_BAD_SPECIAL, "bad-protx-netinfo-addr-type");
+    case NetInfoStatus::NotRoutable:
+        return state.Invalid(TxValidationResult::TX_BAD_SPECIAL, "bad-protx-netinfo-addr-unroutable");
+    case NetInfoStatus::Malformed:
+        return state.Invalid(TxValidationResult::TX_BAD_SPECIAL, "bad-protx-netinfo-bad");
+    case NetInfoStatus::Success:
+        return true;
+    // Shouldn't be possible during self-checks
+    case NetInfoStatus::BadInput:
+    case NetInfoStatus::Duplicate:
+    case NetInfoStatus::MaxLimit:
+        assert(false);
+    } // no default case, so the compiler can warn about missing cases
+    assert(false);
+}
+
+template <typename ProTx>
+static bool CheckPlatformFields(const ProTx& proTx, bool is_extended_addr, TxValidationState& state)
+{
+    if (proTx.platformNodeID.IsNull()) {
+        return state.Invalid(TxValidationResult::TX_BAD_SPECIAL, "bad-protx-platform-nodeid");
+    }
+
+    if (is_extended_addr) {
+        // platformHTTPPort and platformP2PPort have been subsumed by netInfo. They should always be zero.
+        if (proTx.platformP2PPort != 0) {
+            return state.Invalid(TxValidationResult::TX_BAD_SPECIAL, "bad-protx-platform-p2p-port");
+        }
+        if (proTx.platformHTTPPort != 0) {
+            return state.Invalid(TxValidationResult::TX_BAD_SPECIAL, "bad-protx-platform-http-port");
+        }
+        return true;
+    }
+
+    if (::IsNodeOnMainnet()) {
+        if (proTx.platformP2PPort != ::MainParams().GetDefaultPlatformP2PPort()) {
+            return state.Invalid(TxValidationResult::TX_BAD_SPECIAL, "bad-protx-platform-p2p-port");
+        }
+        if (proTx.platformHTTPPort != ::MainParams().GetDefaultPlatformHTTPPort()) {
+            return state.Invalid(TxValidationResult::TX_BAD_SPECIAL, "bad-protx-platform-http-port");
+        }
+    }
+    if (proTx.platformP2PPort == ::MainParams().GetDefaultPort()) {
+        return state.Invalid(TxValidationResult::TX_BAD_SPECIAL, "bad-protx-platform-p2p-port");
+    }
+    if (proTx.platformHTTPPort == ::MainParams().GetDefaultPort()) {
+        return state.Invalid(TxValidationResult::TX_BAD_SPECIAL, "bad-protx-platform-http-port");
+    }
+
+    const uint16_t core_port{proTx.netInfo->GetPrimary().GetPort()};
+    if (proTx.platformP2PPort == proTx.platformHTTPPort || proTx.platformP2PPort == core_port ||
+        proTx.platformHTTPPort == core_port) {
+        return state.Invalid(TxValidationResult::TX_BAD_SPECIAL, "bad-protx-platform-dup-ports");
+    }
+
+    return true;
+}
+
+template <typename ProTx>
+static bool CheckHashSig(const ProTx& proTx, const PKHash& pkhash, TxValidationState& state)
+{
+    if (std::string strError; !CHashSigner::VerifyHash(::SerializeHash(proTx), ToKeyID(pkhash), proTx.vchSig, strError)) {
+        return state.Invalid(TxValidationResult::TX_CONSENSUS, "bad-protx-sig");
+    }
+    return true;
+}
+
+template <typename ProTx>
+static bool CheckStringSig(const ProTx& proTx, const PKHash& pkhash, TxValidationState& state)
+{
+    if (std::string strError;
+        !CMessageSigner::VerifyMessage(ToKeyID(pkhash), proTx.vchSig, proTx.MakeSignString(), strError)) {
+        return state.Invalid(TxValidationResult::TX_CONSENSUS, "bad-protx-sig");
+    }
+    return true;
+}
+
+template <typename ProTx>
+static bool CheckHashSig(const ProTx& proTx, const CBLSPublicKey& pubKey, TxValidationState& state)
+{
+    if (!proTx.sig.VerifyInsecure(pubKey, ::SerializeHash(proTx))) {
+        return state.Invalid(TxValidationResult::TX_CONSENSUS, "bad-protx-sig");
+    }
+    return true;
+}
+
+template <typename ProTx>
+static std::optional<ProTx> GetValidatedPayload(const CTransaction& tx, gsl::not_null<const CBlockIndex*> pindexPrev,
+                                                const ChainstateManager& chainman, TxValidationState& state)
+{
+    if (tx.nType != ProTx::SPECIALTX_TYPE) {
+        state.Invalid(TxValidationResult::TX_CONSENSUS, "bad-protx-type");
+        return std::nullopt;
+    }
+
+    auto opt_ptx = GetTxPayload<ProTx>(tx);
+    if (!opt_ptx) {
+        state.Invalid(TxValidationResult::TX_CONSENSUS, "bad-protx-payload");
+        return std::nullopt;
+    }
+    if (!opt_ptx->IsTriviallyValid(pindexPrev, chainman, state)) {
+        // pass the state returned by the function above
+        return std::nullopt;
+    }
+    return opt_ptx;
+}
+
+/**
+ * Validates potential changes to masternode state version by ProTx transaction version
+ * @param[in]  pindexPrev    Previous block index to validate DEPLOYMENT_V24 activation
+ * @param[in]  tx_type       Special transaction type
+ * @param[in]  state_version Current masternode state version
+ * @param[in]  tx_version    Proposed transaction version
+ * @param[out] state         This may be set to an Error state if any error occurred processing them
+ * @returns                  true if version change is valid or DEPLOYMENT_V24 is not active
+ */
+static bool IsVersionChangeValid(gsl::not_null<const CBlockIndex*> pindexPrev, const uint16_t tx_type,
+                                 const uint16_t state_version, const uint16_t tx_version,
+                                 const ChainstateManager& chainman, TxValidationState& state)
+{
+    if (!DeploymentActiveAfter(pindexPrev, chainman, Consensus::DEPLOYMENT_V24)) {
+        // New restrictions only apply after v24 deployment
+        return true;
+    }
+
+    if (state_version >= ProTxVersion::BasicBLS && tx_version == ProTxVersion::LegacyBLS) {
+        // Don't allow legacy scheme versioned transactions after upgrading to basic scheme
+        return state.Invalid(TxValidationResult::TX_CONSENSUS, "bad-protx-version-downgrade");
+    }
+
+    if (state_version == ProTxVersion::LegacyBLS && tx_version > ProTxVersion::BasicBLS) {
+        // Nodes using the legacy scheme must first upgrade to the basic scheme before upgrading further
+        return state.Invalid(TxValidationResult::TX_CONSENSUS, "bad-protx-version-upgrade");
+    }
+
+    if (tx_type != TRANSACTION_PROVIDER_UPDATE_SERVICE && tx_version == ProTxVersion::ExtAddr) {
+        // Only new entries (ProRegTx) and service updates (ProUpServTx) can use ExtAddr versioning
+        return state.Invalid(TxValidationResult::TX_CONSENSUS, "bad-protx-version-tx-type");
+    }
+
+    return true;
+}
+
+bool CheckProRegTx(const CTransaction& tx, gsl::not_null<const CBlockIndex*> pindexPrev,
+                   CDeterministicMNManager& dmnman, const CCoinsViewCache& view, const ChainstateManager& chainman,
+                   TxValidationState& state, bool check_sigs)
+{
+    const auto opt_ptx = GetValidatedPayload<CProRegTx>(tx, pindexPrev, chainman, state);
+    if (!opt_ptx) {
+        // pass the state returned by the function above
+        return false;
+    }
+
+    const bool is_v24_active{DeploymentActiveAfter(pindexPrev, chainman, Consensus::DEPLOYMENT_V24)};
+
+    // No longer allow legacy scheme masternode registration
+    if (is_v24_active && opt_ptx->nVersion < ProTxVersion::BasicBLS) {
+        return state.Invalid(TxValidationResult::TX_CONSENSUS, "bad-protx-version-disallowed");
+    }
+
+    // It's allowed to set addr to 0, which will put the MN into PoSe-banned state and require a ProUpServTx to be
+    // issues later. If any of both is set, it must be valid however
+    if (!opt_ptx->netInfo->IsEmpty() && !CheckService(*opt_ptx, state)) {
+        // pass the state returned by the function above
+        return false;
+    }
+
+    if (opt_ptx->nType == MnType::Evo) {
+        if (!CheckPlatformFields(*opt_ptx, opt_ptx->nVersion >= ProTxVersion::ExtAddr, state)) {
+            return false;
+        }
+    }
+
+    CTxDestination collateralTxDest;
+    const PKHash* keyForPayloadSig = nullptr;
+    COutPoint collateralOutpoint;
+
+    CAmount expectedCollateral = GetMnType(opt_ptx->nType).collat_amount;
+
+    if (!opt_ptx->collateralOutpoint.hash.IsNull()) {
+        Coin coin;
+        if (!view.GetCoin(opt_ptx->collateralOutpoint, coin) || coin.IsSpent() || coin.out.nValue != expectedCollateral) {
+            return state.Invalid(TxValidationResult::TX_BAD_SPECIAL, "bad-protx-collateral");
+        }
+
+        if (!ExtractDestination(coin.out.scriptPubKey, collateralTxDest)) {
+            return state.Invalid(TxValidationResult::TX_BAD_SPECIAL, "bad-protx-collateral-dest");
+        }
+
+        // Extract key from collateral. This only works for P2PK and P2PKH collaterals and will fail for P2SH.
+        // Issuer of this ProRegTx must prove ownership with this key by signing the ProRegTx
+        keyForPayloadSig = std::get_if<PKHash>(&collateralTxDest);
+        if (!keyForPayloadSig) {
+            return state.Invalid(TxValidationResult::TX_BAD_SPECIAL, "bad-protx-collateral-pkh");
+        }
+
+        collateralOutpoint = opt_ptx->collateralOutpoint;
+    } else {
+        if (opt_ptx->collateralOutpoint.n >= tx.vout.size()) {
+            return state.Invalid(TxValidationResult::TX_BAD_SPECIAL, "bad-protx-collateral-index");
+        }
+        if (tx.vout[opt_ptx->collateralOutpoint.n].nValue != expectedCollateral) {
+            return state.Invalid(TxValidationResult::TX_BAD_SPECIAL, "bad-protx-collateral");
+        }
+
+        if (!ExtractDestination(tx.vout[opt_ptx->collateralOutpoint.n].scriptPubKey, collateralTxDest)) {
+            return state.Invalid(TxValidationResult::TX_BAD_SPECIAL, "bad-protx-collateral-dest");
+        }
+
+        collateralOutpoint = COutPoint(tx.GetHash(), opt_ptx->collateralOutpoint.n);
+    }
+
+    // don't allow reuse of collateral key for other keys (don't allow people to put the collateral key onto an online server)
+    // this check applies to internal and external collateral, but internal collaterals are not necessarily a P2PKH
+    if (collateralTxDest == CTxDestination(PKHash(opt_ptx->keyIDOwner)) ||
+        collateralTxDest == CTxDestination(PKHash(opt_ptx->keyIDVoting))) {
+        return state.Invalid(TxValidationResult::TX_BAD_SPECIAL, "bad-protx-collateral-reuse");
+    }
+
+    if (pindexPrev) {
+        auto mnList = dmnman.GetListForBlock(pindexPrev);
+
+        // only allow reusing of addresses when it's for the same collateral (which replaces the old MN)
+        for (const auto& entry : opt_ptx->netInfo->GetEntries()) {
+            if (const auto service_opt{entry.GetAddrPort()}) {
+                if (mnList.HasUniqueProperty(*service_opt) &&
+                    mnList.GetUniquePropertyMN(*service_opt)->collateralOutpoint != collateralOutpoint) {
+                    return state.Invalid(TxValidationResult::TX_BAD_SPECIAL, "bad-protx-dup-netinfo-entry");
+                }
+            } else if (const auto domain_opt{entry.GetDomainPort()}) {
+                if (mnList.HasUniqueProperty(*domain_opt) &&
+                    mnList.GetUniquePropertyMN(*domain_opt)->collateralOutpoint != collateralOutpoint) {
+                    return state.Invalid(TxValidationResult::TX_BAD_SPECIAL, "bad-protx-dup-netinfo-entry");
+                }
+            } else {
+                return state.Invalid(TxValidationResult::TX_BAD_SPECIAL, "bad-protx-netinfo-entry");
+            }
+        }
+
+        // never allow duplicate keys, even if this ProTx would replace an existing MN
+        if (mnList.HasUniqueProperty(opt_ptx->keyIDOwner) || mnList.HasUniqueProperty(opt_ptx->pubKeyOperator)) {
+            return state.Invalid(TxValidationResult::TX_BAD_SPECIAL, "bad-protx-dup-key");
+        }
+
+        // never allow duplicate platformNodeIds for EvoNodes
+        if (opt_ptx->nType == MnType::Evo) {
+            if (mnList.HasUniqueProperty(opt_ptx->platformNodeID)) {
+                return state.Invalid(TxValidationResult::TX_BAD_SPECIAL, "bad-protx-dup-platformnodeid");
+            }
+        }
+
+        if (!DeploymentDIP0003Enforced(pindexPrev->nHeight, Params().GetConsensus())) {
+            if (opt_ptx->keyIDOwner != opt_ptx->keyIDVoting) {
+                return state.Invalid(TxValidationResult::TX_BAD_SPECIAL, "bad-protx-key-not-same");
+            }
+        }
+    }
+
+    if (!CheckInputsHash(tx, *opt_ptx, state)) {
+        // pass the state returned by the function above
+        return false;
+    }
+
+    if (keyForPayloadSig) {
+        // collateral is not part of this ProRegTx, so we must verify ownership of the collateral
+        if (check_sigs && !CheckStringSig(*opt_ptx, *keyForPayloadSig, state)) {
+            // pass the state returned by the function above
+            return false;
+        }
+    } else {
+        // collateral is part of this ProRegTx, so we know the collateral is owned by the issuer
+        if (!opt_ptx->vchSig.empty()) {
+            return state.Invalid(TxValidationResult::TX_CONSENSUS, "bad-protx-sig");
+        }
+    }
+
+    return true;
+}
+
+bool CheckProUpServTx(const CTransaction& tx, gsl::not_null<const CBlockIndex*> pindexPrev, CDeterministicMNManager& dmnman,
+                      const ChainstateManager& chainman, TxValidationState& state, bool check_sigs)
+{
+    const auto opt_ptx = GetValidatedPayload<CProUpServTx>(tx, pindexPrev, chainman, state);
+    if (!opt_ptx) {
+        // pass the state returned by the function above
+        return false;
+    }
+
+    if (!CheckService(*opt_ptx, state)) {
+        // pass the state returned by the function above
+        return false;
+    }
+
+    if (opt_ptx->nType == MnType::Evo) {
+        if (!CheckPlatformFields(*opt_ptx, opt_ptx->nVersion >= ProTxVersion::ExtAddr, state)) {
+            return false;
+        }
+    }
+
+    auto mnList = dmnman.GetListForBlock(pindexPrev);
+    auto dmn = mnList.GetMN(opt_ptx->proTxHash);
+    if (!dmn) {
+        return state.Invalid(TxValidationResult::TX_CONSENSUS, "bad-protx-hash");
+    }
+
+    if (!IsVersionChangeValid(pindexPrev, tx.nType, dmn->pdmnState->nVersion, opt_ptx->nVersion, chainman, state)) {
+        // pass the state returned by the function above
+        return false;
+    }
+
+    // don't allow updating to addresses already used by other MNs
+    for (const auto& entry : opt_ptx->netInfo->GetEntries()) {
+        if (const auto service_opt{entry.GetAddrPort()}) {
+            if (mnList.HasUniqueProperty(*service_opt) &&
+                mnList.GetUniquePropertyMN(*service_opt)->proTxHash != opt_ptx->proTxHash) {
+                return state.Invalid(TxValidationResult::TX_BAD_SPECIAL, "bad-protx-dup-netinfo-entry");
+            }
+        } else if (const auto domain_opt{entry.GetDomainPort()}) {
+            if (mnList.HasUniqueProperty(*domain_opt) &&
+                mnList.GetUniquePropertyMN(*domain_opt)->proTxHash != opt_ptx->proTxHash) {
+                return state.Invalid(TxValidationResult::TX_BAD_SPECIAL, "bad-protx-dup-netinfo-entry");
+            }
+        } else {
+            return state.Invalid(TxValidationResult::TX_BAD_SPECIAL, "bad-protx-netinfo-entry");
+        }
+    }
+
+    // don't allow updating to platformNodeIds already used by other EvoNodes
+    if (opt_ptx->nType == MnType::Evo) {
+        if (mnList.HasUniqueProperty(opt_ptx->platformNodeID) &&
+            mnList.GetUniquePropertyMN(opt_ptx->platformNodeID)->proTxHash != opt_ptx->proTxHash) {
+            return state.Invalid(TxValidationResult::TX_BAD_SPECIAL, "bad-protx-dup-platformnodeid");
+        }
+    }
+
+    if (opt_ptx->scriptOperatorPayout != CScript()) {
+        if (dmn->nOperatorReward == 0) {
+            // don't allow setting operator reward payee in case no operatorReward was set
+            return state.Invalid(TxValidationResult::TX_BAD_SPECIAL, "bad-protx-operator-payee");
+        }
+        if (!opt_ptx->scriptOperatorPayout.IsPayToPublicKeyHash() && !opt_ptx->scriptOperatorPayout.IsPayToScriptHash()) {
+            return state.Invalid(TxValidationResult::TX_BAD_SPECIAL, "bad-protx-operator-payee");
+        }
+    }
+
+    // we can only check the signature if pindexPrev != nullptr and the MN is known
+    if (!CheckInputsHash(tx, *opt_ptx, state)) {
+        // pass the state returned by the function above
+        return false;
+    }
+    if (check_sigs && !CheckHashSig(*opt_ptx, dmn->pdmnState->pubKeyOperator.Get(), state)) {
+        // pass the state returned by the function above
+        return false;
+    }
+
+    return true;
+}
+
+bool CheckProUpRegTx(const CTransaction& tx, gsl::not_null<const CBlockIndex*> pindexPrev,
+                     CDeterministicMNManager& dmnman, const CCoinsViewCache& view, const ChainstateManager& chainman,
+                     TxValidationState& state, bool check_sigs)
+{
+    const auto opt_ptx = GetValidatedPayload<CProUpRegTx>(tx, pindexPrev, chainman, state);
+    if (!opt_ptx) {
+        // pass the state returned by the function above
+        return false;
+    }
+
+    CTxDestination payoutDest;
+    if (!ExtractDestination(opt_ptx->scriptPayout, payoutDest)) {
+        // should not happen as we checked script types before
+        return state.Invalid(TxValidationResult::TX_BAD_SPECIAL, "bad-protx-payee-dest");
+    }
+
+    auto mnList = dmnman.GetListForBlock(pindexPrev);
+    auto dmn = mnList.GetMN(opt_ptx->proTxHash);
+    if (!dmn) {
+        return state.Invalid(TxValidationResult::TX_CONSENSUS, "bad-protx-hash");
+    }
+
+    if (!IsVersionChangeValid(pindexPrev, tx.nType, dmn->pdmnState->nVersion, opt_ptx->nVersion, chainman, state)) {
+        // pass the state returned by the function above
+        return false;
+    }
+
+    // don't allow reuse of payee key for other keys (don't allow people to put the payee key onto an online server)
+    if (payoutDest == CTxDestination(PKHash(dmn->pdmnState->keyIDOwner)) ||
+        payoutDest == CTxDestination(PKHash(opt_ptx->keyIDVoting))) {
+        return state.Invalid(TxValidationResult::TX_BAD_SPECIAL, "bad-protx-payee-reuse");
+    }
+
+    Coin coin;
+    if (!view.GetCoin(dmn->collateralOutpoint, coin) || coin.IsSpent()) {
+        // this should never happen (there would be no dmn otherwise)
+        return state.Invalid(TxValidationResult::TX_CONSENSUS, "bad-protx-collateral");
+    }
+
+    // don't allow reuse of collateral key for other keys (don't allow people to put the collateral key onto an online server)
+    CTxDestination collateralTxDest;
+    if (!ExtractDestination(coin.out.scriptPubKey, collateralTxDest)) {
+        return state.Invalid(TxValidationResult::TX_CONSENSUS, "bad-protx-collateral-dest");
+    }
+    if (collateralTxDest == CTxDestination(PKHash(dmn->pdmnState->keyIDOwner)) ||
+        collateralTxDest == CTxDestination(PKHash(opt_ptx->keyIDVoting))) {
+        return state.Invalid(TxValidationResult::TX_BAD_SPECIAL, "bad-protx-collateral-reuse");
+    }
+
+    if (mnList.HasUniqueProperty(opt_ptx->pubKeyOperator)) {
+        auto otherDmn = mnList.GetUniquePropertyMN(opt_ptx->pubKeyOperator);
+        if (opt_ptx->proTxHash != otherDmn->proTxHash) {
+            return state.Invalid(TxValidationResult::TX_BAD_SPECIAL, "bad-protx-dup-key");
+        }
+    }
+
+    if (!DeploymentDIP0003Enforced(pindexPrev->nHeight, Params().GetConsensus())) {
+        if (dmn->pdmnState->keyIDOwner != opt_ptx->keyIDVoting) {
+            return state.Invalid(TxValidationResult::TX_BAD_SPECIAL, "bad-protx-key-not-same");
+        }
+    }
+
+    if (!CheckInputsHash(tx, *opt_ptx, state)) {
+        // pass the state returned by the function above
+        return false;
+    }
+    if (check_sigs && !CheckHashSig(*opt_ptx, PKHash(dmn->pdmnState->keyIDOwner), state)) {
+        // pass the state returned by the function above
+        return false;
+    }
+
+    return true;
+}
+
+bool CheckProUpRevTx(const CTransaction& tx, gsl::not_null<const CBlockIndex*> pindexPrev, CDeterministicMNManager& dmnman,
+                     const ChainstateManager& chainman, TxValidationState& state, bool check_sigs)
+{
+    const auto opt_ptx = GetValidatedPayload<CProUpRevTx>(tx, pindexPrev, chainman, state);
+    if (!opt_ptx) {
+        // pass the state returned by the function above
+        return false;
+    }
+
+    auto mnList = dmnman.GetListForBlock(pindexPrev);
+    auto dmn = mnList.GetMN(opt_ptx->proTxHash);
+    if (!dmn) {
+        return state.Invalid(TxValidationResult::TX_CONSENSUS, "bad-protx-hash");
+    }
+
+    if (!IsVersionChangeValid(pindexPrev, tx.nType, dmn->pdmnState->nVersion, opt_ptx->nVersion, chainman, state)) {
+        // pass the state returned by the function above
+        return false;
+    }
+
+    if (!CheckInputsHash(tx, *opt_ptx, state)) {
+        // pass the state returned by the function above
+        return false;
+    }
+    if (check_sigs && !CheckHashSig(*opt_ptx, dmn->pdmnState->pubKeyOperator.Get(), state)) {
+        // pass the state returned by the function above
+        return false;
+    }
+
+    return true;
+}
diff --git a/src/evo/specialtxman.h b/src/evo/specialtxman.h
index de293d0dfaba..c82f2b7afe19 100644
--- a/src/evo/specialtxman.h
+++ b/src/evo/specialtxman.h
@@ -90,4 +90,16 @@ class CSpecialTxProcessor
                                      BlockValidationState& state) EXCLUSIVE_LOCKS_REQUIRED(::cs_main);
 };
 
+
+bool CheckProRegTx(const CTransaction& tx, gsl::not_null<const CBlockIndex*> pindexPrev,
+                   CDeterministicMNManager& dmnman, const CCoinsViewCache& view, const ChainstateManager& chainman,
+                   TxValidationState& state, bool check_sigs);
+bool CheckProUpServTx(const CTransaction& tx, gsl::not_null<const CBlockIndex*> pindexPrev, CDeterministicMNManager& dmnman,
+                      const ChainstateManager& chainman, TxValidationState& state, bool check_sigs);
+bool CheckProUpRegTx(const CTransaction& tx, gsl::not_null<const CBlockIndex*> pindexPrev,
+                     CDeterministicMNManager& dmnman, const CCoinsViewCache& view, const ChainstateManager& chainman,
+                     TxValidationState& state, bool check_sigs);
+bool CheckProUpRevTx(const CTransaction& tx, gsl::not_null<const CBlockIndex*> pindexPrev, CDeterministicMNManager& dmnman,
+                     const ChainstateManager& chainman, TxValidationState& state, bool check_sigs);
+
 #endif // BITCOIN_EVO_SPECIALTXMAN_H
diff --git a/src/init.cpp b/src/init.cpp
index 6e79ed5b0d21..7a2ca65192d7 100644
--- a/src/init.cpp
+++ b/src/init.cpp
@@ -87,7 +87,6 @@
 #include <evo/chainhelper.h>
 #include <evo/deterministicmns.h>
 #include <evo/evodb.h>
-#include <evo/mnhftx.h>
 #include <evo/specialtxman.h>
 #include <flat-database.h>
 #include <governance/governance.h>
@@ -401,9 +400,8 @@ void PrepareShutdown(NodeContext& node)
                 chainstate->ResetCoinsViews();
             }
         }
-        DashChainstateSetupClose(node.chain_helper, node.cpoolman, node.dmnman, node.mnhf_manager, node.llmq_ctx,
+        DashChainstateSetupClose(node.chain_helper, node.dmnman, node.llmq_ctx,
                                  Assert(node.mempool.get()));
-        node.mnhf_manager.reset();
         node.evodb.reset();
     }
     for (const auto& client : node.chain_clients) {
@@ -1999,10 +1997,8 @@ bool AppInitMain(NodeContext& node, interfaces::BlockAndHeaderTipInfo* tip_info)
                                               *node.mn_sync,
                                               *node.sporkman,
                                               node.chain_helper,
-                                              node.cpoolman,
                                               node.dmnman,
                                               node.evodb,
-                                              node.mnhf_manager,
                                               node.llmq_ctx,
                                               Assert(node.mempool.get()),
                                               args.GetDataDirNet(),
@@ -2201,7 +2197,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.mn_metaman,
-                                                          *node.mnhf_manager, *node.sporkman, *node.mempool, *node.llmq_ctx->clhandler, *node.llmq_ctx->isman,
+                                                          *node.sporkman, *node.mempool, *node.llmq_ctx->clhandler, *node.llmq_ctx->isman,
                                                           *node.llmq_ctx->quorum_block_processor, *node.llmq_ctx->qman, *node.llmq_ctx->qsnapman, *node.llmq_ctx->sigman,
                                                           *node.peerman, *node.mn_sync, operator_sk, sync_map, dash_db_params, quorums_recovery, quorums_watch);
         RegisterValidationInterface(node.active_ctx.get());
diff --git a/src/llmq/context.h b/src/llmq/context.h
index 1e2e84e25a0e..7a8f9329ed7b 100644
--- a/src/llmq/context.h
+++ b/src/llmq/context.h
@@ -9,7 +9,6 @@
 
 #include <memory>
 
-class CActiveMasternodeManager;
 class CBLSWorker;
 class ChainstateManager;
 class CDeterministicMNManager;
diff --git a/src/llmq/ehf_signals.cpp b/src/llmq/ehf_signals.cpp
index 394f325c4297..726d615d46d7 100644
--- a/src/llmq/ehf_signals.cpp
+++ b/src/llmq/ehf_signals.cpp
@@ -7,20 +7,20 @@
 #include <chainparams.h>
 #include <consensus/validation.h>
 #include <deploymentstatus.h>
-#include <index/txindex.h> // g_txindex
-#include <primitives/transaction.h>
-#include <validation.h>
-
+#include <evo/chainhelper.h>
 #include <evo/mnhftx.h>
+#include <index/txindex.h> // g_txindex
 #include <llmq/commitment.h>
 #include <llmq/quorumsman.h>
 #include <llmq/signing_shares.h>
+#include <primitives/transaction.h>
+#include <validation.h>
+#include <versionbits.h>
 
 namespace llmq {
-CEHFSignalsHandler::CEHFSignalsHandler(ChainstateManager& chainman, CMNHFManager& mnhfman, CSigningManager& sigman,
+CEHFSignalsHandler::CEHFSignalsHandler(ChainstateManager& chainman, CSigningManager& sigman,
                                        CSigSharesManager& shareman, const CQuorumManager& qman) :
     m_chainman(chainman),
-    mnhfman(mnhfman),
     sigman(sigman),
     shareman(shareman),
     qman(qman)
@@ -37,7 +37,7 @@ void CEHFSignalsHandler::UpdatedBlockTip(const CBlockIndex* const pindexNew)
 {
     if (!DeploymentActiveAfter(pindexNew, Params().GetConsensus(), Consensus::DEPLOYMENT_V20)) return;
 
-    const auto ehfSignals = mnhfman.GetSignalsStage(pindexNew);
+    const auto ehfSignals = m_chainman.ActiveChainstate().ChainHelper().ehf_manager->GetSignalsStage(pindexNew);
     for (const auto& deployment : Params().GetConsensus().vDeployments) {
         // Skip deployments that do not use dip0023
         if (!deployment.useEHF) continue;
@@ -93,7 +93,8 @@ MessageProcessingResult CEHFSignalsHandler::HandleNewRecoveredSig(const CRecover
     }
 
     MessageProcessingResult ret;
-    const auto ehfSignals = mnhfman.GetSignalsStage(WITH_LOCK(::cs_main, return m_chainman.ActiveTip()));
+    const auto ehfSignals = m_chainman.ActiveChainstate().ChainHelper().ehf_manager->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 cc9893061dca..cb3b32b16251 100644
--- a/src/llmq/ehf_signals.h
+++ b/src/llmq/ehf_signals.h
@@ -12,7 +12,6 @@
 
 class CBlockIndex;
 class ChainstateManager;
-class CMNHFManager;
 
 namespace llmq {
 class CQuorumManager;
@@ -23,7 +22,6 @@ class CEHFSignalsHandler : public CRecoveredSigsListener
 {
 private:
     ChainstateManager& m_chainman;
-    CMNHFManager& mnhfman;
     CSigningManager& sigman;
     CSigSharesManager& shareman;
     const CQuorumManager& qman;
@@ -34,8 +32,8 @@ class CEHFSignalsHandler : public CRecoveredSigsListener
     mutable Mutex cs;
     std::set<uint256> ids GUARDED_BY(cs);
 public:
-    explicit CEHFSignalsHandler(ChainstateManager& chainman, CMNHFManager& mnhfman, CSigningManager& sigman,
-                                CSigSharesManager& shareman, const CQuorumManager& qman);
+    explicit CEHFSignalsHandler(ChainstateManager& chainman, CSigningManager& sigman, CSigSharesManager& shareman,
+                                const CQuorumManager& qman);
 
     ~CEHFSignalsHandler();
 
diff --git a/src/node/chainstate.cpp b/src/node/chainstate.cpp
index e60eaace5630..69abeee2833a 100644
--- a/src/node/chainstate.cpp
+++ b/src/node/chainstate.cpp
@@ -21,7 +21,6 @@
 
 #include <bls/bls.h>
 #include <evo/chainhelper.h>
-#include <evo/creditpool.h>
 #include <evo/deterministicmns.h>
 #include <evo/evodb.h>
 #include <evo/mnhftx.h>
@@ -41,10 +40,8 @@ std::optional<ChainstateLoadingError> LoadChainstate(bool fReset,
                                                      CMasternodeSync& mn_sync,
                                                      CSporkManager& sporkman,
                                                      std::unique_ptr<CChainstateHelper>& chain_helper,
-                                                     std::unique_ptr<CCreditPoolManager>& cpoolman,
                                                      std::unique_ptr<CDeterministicMNManager>& dmnman,
                                                      std::unique_ptr<CEvoDB>& evodb,
-                                                     std::unique_ptr<CMNHFManager>& mnhf_manager,
                                                      std::unique_ptr<LLMQContext>& llmq_ctx,
                                                      CTxMemPool* mempool,
                                                      const fs::path& data_dir,
@@ -74,9 +71,6 @@ std::optional<ChainstateLoadingError> LoadChainstate(bool fReset,
     evodb.reset();
     evodb = std::make_unique<CEvoDB>(util::DbWrapperParams{.path = data_dir, .memory = dash_dbs_in_memory, .wipe = fReset || fReindexChainState});
 
-    mnhf_manager.reset();
-    mnhf_manager = std::make_unique<CMNHFManager>(*evodb, chainman);
-
     chainman.InitializeChainstate(mempool, *evodb, chain_helper);
     chainman.m_total_coinstip_cache = nCoinCacheUsage;
     chainman.m_total_coinsdb_cache = nCoinDBCache;
@@ -87,8 +81,8 @@ std::optional<ChainstateLoadingError> LoadChainstate(bool fReset,
     pblocktree.reset();
     pblocktree.reset(new CBlockTreeDB(nBlockTreeDBCache, block_tree_db_in_memory, fReset));
 
-    DashChainstateSetup(chainman, govman, mn_metaman, mn_sync, sporkman, chain_helper, cpoolman,
-                        dmnman, evodb, mnhf_manager, llmq_ctx, mempool, data_dir, dash_dbs_in_memory,
+    DashChainstateSetup(chainman, govman, mn_metaman, mn_sync, sporkman, chain_helper,
+                        dmnman, *evodb, llmq_ctx, mempool, data_dir, dash_dbs_in_memory,
                         /*llmq_dbs_wipe=*/fReset || fReindexChainState, bls_threads, max_recsigs_age, consensus_params);
 
     if (fReset) {
@@ -197,7 +191,7 @@ std::optional<ChainstateLoadingError> LoadChainstate(bool fReset,
         }
     }
 
-    if (!mnhf_manager->ForceSignalDBUpdate()) {
+    if (!chain_helper->ehf_manager->ForceSignalDBUpdate()) {
         return ChainstateLoadingError::ERROR_UPGRADING_SIGNALS_DB;
     }
 
@@ -215,10 +209,8 @@ void DashChainstateSetup(ChainstateManager& chainman,
                          CMasternodeSync& mn_sync,
                          CSporkManager& sporkman,
                          std::unique_ptr<CChainstateHelper>& chain_helper,
-                         std::unique_ptr<CCreditPoolManager>& cpoolman,
                          std::unique_ptr<CDeterministicMNManager>& dmnman,
-                         std::unique_ptr<CEvoDB>& evodb,
-                         std::unique_ptr<CMNHFManager>& mnhf_manager,
+                         CEvoDB& evodb,
                          std::unique_ptr<LLMQContext>& llmq_ctx,
                          CTxMemPool* mempool,
                          const fs::path& data_dir,
@@ -230,42 +222,30 @@ void DashChainstateSetup(ChainstateManager& chainman,
 {
     // Same logic as pblocktree
     dmnman.reset();
-    dmnman = std::make_unique<CDeterministicMNManager>(*evodb, mn_metaman);
-
-    cpoolman.reset();
-    cpoolman = std::make_unique<CCreditPoolManager>(*evodb, chainman);
+    dmnman = std::make_unique<CDeterministicMNManager>(evodb, mn_metaman);
 
     if (llmq_ctx) {
         llmq_ctx->Stop();
     }
     llmq_ctx.reset();
-    llmq_ctx = std::make_unique<LLMQContext>(*dmnman, *evodb, sporkman, *mempool, chainman, mn_sync,
+    llmq_ctx = std::make_unique<LLMQContext>(*dmnman, evodb, sporkman, *mempool, chainman, mn_sync,
                                              util::DbWrapperParams{.path = data_dir, .memory = llmq_dbs_in_memory, .wipe = llmq_dbs_wipe},
                                              bls_threads, max_recsigs_age);
     mempool->ConnectManagers(dmnman.get(), llmq_ctx->isman.get());
-    // Enable CMNHFManager::{Process, Undo}Block
-    mnhf_manager->ConnectManagers(llmq_ctx->qman.get());
-
     chain_helper.reset();
-    chain_helper = std::make_unique<CChainstateHelper>(*cpoolman, *dmnman, *mnhf_manager, govman, *(llmq_ctx->isman), *(llmq_ctx->quorum_block_processor),
+    chain_helper = std::make_unique<CChainstateHelper>(evodb, *dmnman, govman, *(llmq_ctx->isman), *(llmq_ctx->quorum_block_processor),
                                                        *(llmq_ctx->qsnapman), chainman, consensus_params, mn_sync, sporkman, *(llmq_ctx->clhandler),
                                                        *(llmq_ctx->qman));
 }
 
 void DashChainstateSetupClose(std::unique_ptr<CChainstateHelper>& chain_helper,
-                              std::unique_ptr<CCreditPoolManager>& cpoolman,
                               std::unique_ptr<CDeterministicMNManager>& dmnman,
-                              std::unique_ptr<CMNHFManager>& mnhf_manager,
                               std::unique_ptr<LLMQContext>& llmq_ctx,
                               CTxMemPool* mempool)
 
 {
     chain_helper.reset();
-    if (mnhf_manager) {
-        mnhf_manager->DisconnectManagers();
-    }
     llmq_ctx.reset();
-    cpoolman.reset();
     mempool->DisconnectManagers();
     dmnman.reset();
 }
diff --git a/src/node/chainstate.h b/src/node/chainstate.h
index 0022b7637d87..bd88ab863286 100644
--- a/src/node/chainstate.h
+++ b/src/node/chainstate.h
@@ -11,16 +11,13 @@
 #include <optional>
 #include <string>
 
-class CActiveMasternodeManager;
 class CChainstateHelper;
-class CCreditPoolManager;
 class CDeterministicMNManager;
 class CEvoDB;
 class CGovernanceManager;
 class ChainstateManager;
 class CMasternodeMetaMan;
 class CMasternodeSync;
-class CMNHFManager;
 class CSporkManager;
 class CTxMemPool;
 struct LLMQContext;
@@ -85,10 +82,8 @@ std::optional<ChainstateLoadingError> LoadChainstate(bool fReset,
                                                      CMasternodeSync& mn_sync,
                                                      CSporkManager& sporkman,
                                                      std::unique_ptr<CChainstateHelper>& chain_helper,
-                                                     std::unique_ptr<CCreditPoolManager>& cpoolman,
                                                      std::unique_ptr<CDeterministicMNManager>& dmnman,
                                                      std::unique_ptr<CEvoDB>& evodb,
-                                                     std::unique_ptr<CMNHFManager>& mnhf_manager,
                                                      std::unique_ptr<LLMQContext>& llmq_ctx,
                                                      CTxMemPool* mempool,
                                                      const fs::path& data_dir,
@@ -116,10 +111,8 @@ void DashChainstateSetup(ChainstateManager& chainman,
                          CMasternodeSync& mn_sync,
                          CSporkManager& sporkman,
                          std::unique_ptr<CChainstateHelper>& chain_helper,
-                         std::unique_ptr<CCreditPoolManager>& cpoolman,
                          std::unique_ptr<CDeterministicMNManager>& dmnman,
-                         std::unique_ptr<CEvoDB>& evodb,
-                         std::unique_ptr<CMNHFManager>& mnhf_manager,
+                         CEvoDB& evodb,
                          std::unique_ptr<LLMQContext>& llmq_ctx,
                          CTxMemPool* mempool,
                          const fs::path& data_dir,
@@ -130,9 +123,7 @@ void DashChainstateSetup(ChainstateManager& chainman,
                          const Consensus::Params& consensus_params);
 
 void DashChainstateSetupClose(std::unique_ptr<CChainstateHelper>& chain_helper,
-                              std::unique_ptr<CCreditPoolManager>& cpoolman,
                               std::unique_ptr<CDeterministicMNManager>& dmnman,
-                              std::unique_ptr<CMNHFManager>& mnhf_manager,
                               std::unique_ptr<LLMQContext>& llmq_ctx,
                               CTxMemPool* mempool);
 
diff --git a/src/node/context.h b/src/node/context.h
index f2d1bdbb9722..80e6aa2a3b3e 100644
--- a/src/node/context.h
+++ b/src/node/context.h
@@ -16,7 +16,6 @@ class CActiveMasternodeManager;
 class AddrMan;
 class CBlockPolicyEstimator;
 class CConnman;
-class CCreditPoolManager;
 class CDeterministicMNManager;
 class CDSTXManager;
 class CChainstateHelper;
@@ -30,7 +29,6 @@ class CNetFulfilledRequestManager;
 class CScheduler;
 class CSporkManager;
 class CTxMemPool;
-class CMNHFManager;
 class NetGroupManager;
 class PeerManager;
 struct ActiveContext;
@@ -82,7 +80,6 @@ struct NodeContext {
     std::unique_ptr<CScheduler> scheduler;
     std::function<void()> rpc_interruption_point = [] {};
     //! Dash managers
-    std::unique_ptr<CCreditPoolManager> cpoolman;
     std::unique_ptr<CJWalletManager> cj_walletman;
     std::unique_ptr<CDSTXManager> dstxman;
     std::unique_ptr<CEvoDB> evodb;
@@ -91,7 +88,6 @@ struct NodeContext {
     std::unique_ptr<CGovernanceManager> govman;
     std::unique_ptr<CMasternodeMetaMan> mn_metaman;
     std::unique_ptr<CMasternodeSync> mn_sync;
-    std::unique_ptr<CMNHFManager> mnhf_manager;
     std::unique_ptr<CNetFulfilledRequestManager> netfulfilledman;
     std::unique_ptr<CSporkManager> sporkman;
     //! Dash contexts
diff --git a/src/node/miner.cpp b/src/node/miner.cpp
index a90b88ba3613..ecab8b97c481 100644
--- a/src/node/miner.cpp
+++ b/src/node/miner.cpp
@@ -29,8 +29,8 @@
 #include <evo/cbtx.h>
 #include <evo/chainhelper.h>
 #include <evo/creditpool.h>
-#include <evo/deterministicmns.h>
 #include <evo/mnhftx.h>
+#include <evo/deterministicmns.h>
 #include <evo/simplifiedmns.h>
 #include <evo/specialtxman.h>
 #include <governance/governance.h>
@@ -71,11 +71,9 @@ BlockAssembler::Options::Options()
 
 BlockAssembler::BlockAssembler(CChainState& chainstate, const NodeContext& node, const CTxMemPool* mempool, const CChainParams& params, const Options& options) :
       m_blockman(chainstate.m_blockman),
-      m_cpoolman(*Assert(node.cpoolman)),
       m_chain_helper(chainstate.ChainHelper()),
       m_chainstate(chainstate),
       m_evoDb(*Assert(node.evodb)),
-      m_mnhfman(*Assert(node.mnhf_manager)),
       m_clhandler(*Assert(Assert(node.llmq_ctx)->clhandler)),
       m_isman(*Assert(Assert(node.llmq_ctx)->isman)),
       chainparams(params),
@@ -306,7 +304,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_cpoolman, m_blockman, m_qman, *pblock, pindexPrev, chainparams.GetConsensus(), blockSubsidy, state);
+                const auto creditPoolDiff = GetCreditPoolDiffForBlock(*m_chain_helper.credit_pool_manager, m_blockman, m_qman, *pblock, pindexPrev, chainparams.GetConsensus(), blockSubsidy, state);
                 if (creditPoolDiff == std::nullopt) {
                     throw std::runtime_error(strprintf("%s: GetCreditPoolDiffForBlock failed: %s", __func__, state.ToString()));
                 }
@@ -468,12 +466,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_cpoolman.GetCreditPool(pindexPrev);
+        CCreditPool creditPool = m_chain_helper.credit_pool_manager->GetCreditPool(pindexPrev);
         creditPoolDiff.emplace(std::move(creditPool), pindexPrev, chainparams.GetConsensus(), 0);
     }
 
     // This map with signals is used only to find duplicates
-    std::unordered_map<uint8_t, int> signals = m_mnhfman.GetSignalsStage(pindexPrev);
+    std::unordered_map<uint8_t, int> signals = m_chain_helper.ehf_manager->GetSignalsStage(pindexPrev);
 
     // mapModifiedTx will store sorted packages after they are modified
     // because some of their txs are already in the block
diff --git a/src/node/miner.h b/src/node/miner.h
index eea4d69884bd..221a9c5de29d 100644
--- a/src/node/miner.h
+++ b/src/node/miner.h
@@ -23,9 +23,7 @@ class CBlockIndex;
 class CChainParams;
 class CChainstateHelper;
 class CConnman;
-class CCreditPoolManager;
 class CEvoDB;
-class CMNHFManager;
 class CScript;
 struct LLMQContext;
 
@@ -167,11 +165,9 @@ class BlockAssembler
     int64_t m_lock_time_cutoff;
 
     BlockManager& m_blockman;
-    CCreditPoolManager& m_cpoolman;
     CChainstateHelper& m_chain_helper;
     CChainState& m_chainstate;
     CEvoDB& m_evoDb;
-    CMNHFManager& m_mnhfman;
     llmq::CChainLocksHandler& m_clhandler;
     llmq::CInstantSendManager& m_isman;
     const CChainParams& chainparams;
diff --git a/src/rpc/blockchain.cpp b/src/rpc/blockchain.cpp
index 203e20da3ba2..46a7a6c184b0 100644
--- a/src/rpc/blockchain.cpp
+++ b/src/rpc/blockchain.cpp
@@ -16,6 +16,7 @@
 #include <consensus/validation.h>
 #include <deploymentinfo.h>
 #include <deploymentstatus.h>
+#include <evo/chainhelper.h>
 #include <fs.h>
 #include <index/blockfilterindex.h>
 #include <index/coinstatsindex.h>
@@ -1549,7 +1550,7 @@ RPCHelpMan getblockchaininfo()
     const CBlockIndex& tip{*CHECK_NONFATAL(active_chainstate.m_chain.Tip())};
     const int height{tip.nHeight};
 
-    const auto ehfSignals{CHECK_NONFATAL(node.mnhf_manager)->GetSignalsStage(&tip)};
+    const auto ehfSignals{active_chainstate.ChainHelper().GetSignalsStage(&tip)};
 
     UniValue obj(UniValue::VOBJ);
     if (args.IsArgSet("-devnet")) {
diff --git a/src/rpc/rawtransaction.cpp b/src/rpc/rawtransaction.cpp
index 5db203c01832..a1d984ae2cd4 100644
--- a/src/rpc/rawtransaction.cpp
+++ b/src/rpc/rawtransaction.cpp
@@ -48,6 +48,7 @@
 #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/providertx.h>
@@ -637,7 +638,7 @@ static RPCHelpMan getassetunlockstatuses()
     const CTxMemPool& mempool = EnsureMemPool(node);
     const LLMQContext& llmq_ctx = EnsureLLMQContext(node);
     const ChainstateManager& chainman = EnsureChainman(node);
-
+    CCreditPoolManager& cpoolman = *chainman.ActiveChainstate().ChainHelper().credit_pool_manager;
     UniValue result_arr(UniValue::VARR);
     const UniValue str_indexes = request.params[0].get_array();
     if (str_indexes.size() > 100) {
@@ -663,7 +664,7 @@ static RPCHelpMan getassetunlockstatuses()
         if (nSpecificCoreHeight.value() < 0 || nSpecificCoreHeight.value() > chainman.ActiveChain().Height()) {
             throw JSONRPCError(RPC_INVALID_PARAMETER, "Block height out of range");
         }
-        poolCL = std::make_optional(CHECK_NONFATAL(node.cpoolman)->GetCreditPool(chainman.ActiveChain()[nSpecificCoreHeight.value()]));
+        poolCL = std::make_optional(cpoolman.GetCreditPool(chainman.ActiveChain()[nSpecificCoreHeight.value()]));
     }
     else {
         const auto pBlockIndexBestCL = [&]() -> const CBlockIndex* {
@@ -682,12 +683,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(node.cpoolman->GetCreditPool(pBlockIndexBestCL)) :
+                 std::make_optional(cpoolman.GetCreditPool(pBlockIndexBestCL)) :
                  std::nullopt;
 
         poolOnTip = [&]() -> std::optional<CCreditPool> {
             if (pTipBlockIndex != pBlockIndexBestCL) {
-                return std::make_optional(node.cpoolman->GetCreditPool(pTipBlockIndex));
+                return std::make_optional(cpoolman.GetCreditPool(pTipBlockIndex));
             }
             return std::nullopt;
         }();
diff --git a/src/test/evo_deterministicmns_tests.cpp b/src/test/evo_deterministicmns_tests.cpp
index c6875aba1f96..31bb0c565f72 100644
--- a/src/test/evo_deterministicmns_tests.cpp
+++ b/src/test/evo_deterministicmns_tests.cpp
@@ -11,6 +11,7 @@
 #include <evo/providertx.h>
 #include <evo/simplifiedmns.h>
 #include <evo/specialtx.h>
+#include <evo/specialtxman.h>
 #include <llmq/context.h>
 #include <messagesigner.h>
 #include <node/transaction.h>
diff --git a/src/test/util/setup_common.cpp b/src/test/util/setup_common.cpp
index 5c1aa4543124..6ccf69f310b1 100644
--- a/src/test/util/setup_common.cpp
+++ b/src/test/util/setup_common.cpp
@@ -55,10 +55,8 @@
 #include <coinjoin/walletman.h>
 #include <evo/cbtx.h>
 #include <evo/chainhelper.h>
-#include <evo/creditpool.h>
 #include <evo/deterministicmns.h>
 #include <evo/evodb.h>
-#include <evo/mnhftx.h>
 #include <evo/simplifiedmns.h>
 #include <evo/specialtx.h>
 #include <evo/specialtxman.h>
@@ -144,14 +142,14 @@ void DashChainstateSetup(ChainstateManager& chainman,
                          const Consensus::Params& consensus_params)
 {
     DashChainstateSetup(chainman, *Assert(node.govman.get()), *Assert(node.mn_metaman.get()), *Assert(node.mn_sync.get()),
-                        *Assert(node.sporkman.get()), node.chain_helper, node.cpoolman, node.dmnman, node.evodb, node.mnhf_manager,
+                        *Assert(node.sporkman.get()), node.chain_helper, node.dmnman, *node.evodb,
                         node.llmq_ctx, Assert(node.mempool.get()), node.args->GetDataDirNet(), llmq_dbs_in_memory, llmq_dbs_wipe,
                         llmq::DEFAULT_BLSCHECK_THREADS, llmq::DEFAULT_MAX_RECOVERED_SIGS_AGE, consensus_params);
 }
 
 void DashChainstateSetupClose(NodeContext& node)
 {
-    DashChainstateSetupClose(node.chain_helper, node.cpoolman, node.dmnman, node.mnhf_manager, node.llmq_ctx,
+    DashChainstateSetupClose(node.chain_helper, node.dmnman, node.llmq_ctx,
                              Assert(node.mempool.get()));
 }
 
@@ -284,7 +282,6 @@ ChainTestingSetup::ChainTestingSetup(const std::string& chainName, const std::ve
     m_node.chainman = std::make_unique<ChainstateManager>(chainparams);
     m_node.chainman->m_blockman.m_block_tree_db = std::make_unique<CBlockTreeDB>(m_cache_sizes.block_tree_db, true);
 
-    m_node.mnhf_manager = std::make_unique<CMNHFManager>(*m_node.evodb, *m_node.chainman);
     m_node.mn_sync = std::make_unique<CMasternodeSync>(std::make_unique<NodeSyncNotifierImpl>(*m_node.connman, *m_node.netfulfilledman));
     m_node.govman = std::make_unique<CGovernanceManager>(*m_node.mn_metaman, *m_node.netfulfilledman, *m_node.chainman, m_node.dmnman, *m_node.mn_sync);
 
@@ -302,7 +299,6 @@ ChainTestingSetup::~ChainTestingSetup()
     GetMainSignals().UnregisterBackgroundSignalScheduler();
     m_node.govman.reset();
     m_node.mn_sync.reset();
-    m_node.mnhf_manager.reset();
     m_node.chainman.reset();
     m_node.mempool.reset();
     m_node.fee_estimator.reset();
@@ -324,10 +320,8 @@ TestingSetup::TestingSetup(const std::string& chainName, const std::vector<const
                                            *Assert(m_node.mn_sync.get()),
                                            *Assert(m_node.sporkman.get()),
                                            m_node.chain_helper,
-                                           m_node.cpoolman,
                                            m_node.dmnman,
                                            m_node.evodb,
-                                           m_node.mnhf_manager,
                                            m_node.llmq_ctx,
                                            Assert(m_node.mempool.get()),
                                            Assert(m_node.args)->GetDataDirNet(),
diff --git a/test/lint/lint-circular-dependencies.py b/test/lint/lint-circular-dependencies.py
index 53f961367958..19a23e3f9a02 100755
--- a/test/lint/lint-circular-dependencies.py
+++ b/test/lint/lint-circular-dependencies.py
@@ -38,9 +38,9 @@
     "consensus/tx_verify -> evo/assetlocktx -> llmq/commitment -> validation -> consensus/tx_verify",
     "consensus/tx_verify -> evo/assetlocktx -> llmq/commitment -> validation -> txmempool -> consensus/tx_verify",
     "evo/assetlocktx -> llmq/commitment -> validation -> txmempool -> evo/assetlocktx",
-    "evo/chainhelper -> evo/specialtxman -> validation -> evo/chainhelper",
-    "evo/deterministicmns -> validation -> evo/deterministicmns",
-    "evo/deterministicmns -> validation -> txmempool -> evo/deterministicmns",
+    "evo/chainhelper -> evo/creditpool -> validation -> evo/chainhelper",
+    "evo/deterministicmns -> evo/providertx -> validation -> evo/deterministicmns",
+    "evo/deterministicmns -> evo/providertx -> validation -> txmempool -> evo/deterministicmns",
     "evo/netinfo -> evo/providertx -> evo/netinfo",
     "evo/netinfo -> evo/providertx -> validation -> txmempool -> evo/netinfo",
     "evo/providertx -> validation -> txmempool -> evo/providertx",