diff --git a/src/active/dkgsession.cpp b/src/active/dkgsession.cpp
index b50bd966f194..7ab5d2756b90 100644
--- a/src/active/dkgsession.cpp
+++ b/src/active/dkgsession.cpp
@@ -92,6 +92,14 @@ std::optional<CDKGContribution> ActiveDKGSession::SendContributions()
             skContrib.MakeNewKey();
         }
 
+        if (i != myIdx && ShouldSimulateError(DKGError::type::CONTRIBUTION_INVALID)) {
+            // Deliver a share that decrypts to an all-zero (structurally invalid)
+            // CBLSSecretKey on the recipient. Used to exercise the DKG intake's
+            // handling of a peer-supplied invalid contribution share.
+            logger.Batch("sending invalid (zero) share to %s", m->dmn->proTxHash.ToString());
+            skContrib = CBLSSecretKey{};
+        }
+
         if (!qc.contributions->Encrypt(i, m->dmn->pdmnState->pubKeyOperator.Get(), skContrib, PROTOCOL_VERSION)) {
             logger.Batch("failed to encrypt contribution for %s", m->dmn->proTxHash.ToString());
             return std::nullopt;
diff --git a/src/bls/bls_worker.cpp b/src/bls/bls_worker.cpp
index 554f060a0767..aeae68b1ed3b 100644
--- a/src/bls/bls_worker.cpp
+++ b/src/bls/bls_worker.cpp
@@ -5,6 +5,7 @@
 #include <bls/bls_worker.h>
 #include <hash.h>
 
+#include <logging.h>
 #include <util/system.h>
 
 #include <memory>
@@ -69,11 +70,6 @@ void CBLSWorker::Stop()
     workerPool.stop(true);
 }
 
-void CBLSWorker::PushJob(std::function<void()> job)
-{
-    workerPool.push([job = std::move(job)](int) { job(); });
-}
-
 #ifndef BUILD_BITCOIN_INTERNAL
 bool CBLSWorker::GenerateContributions(int quorumThreshold, Span<CBLSId> ids, BLSVerificationVectorPtr& vvecRet, std::vector<CBLSSecretKey>& skSharesRet)
 {
@@ -304,8 +300,14 @@ struct Aggregator : public std::enable_shared_from_this<Aggregator<T>> {
     template <typename TP>
     static T SyncAggregate(Span<TP> vec, size_t start, size_t count)
     {
+        // Defence in depth: AggregateInsecure() asserts that every operand is valid, so
+        // peer-influenced data (e.g. a decrypted contribution share) must never reach it
+        // while invalid. Short-circuit to an invalid aggregate instead; callers already
+        // treat an invalid result as an aggregation failure rather than aborting.
         T result = *vec[start];
+        if (!result.IsValid()) return {};
         for (size_t j = 1; j < count; j++) {
+            if (!vec[start + j]->IsValid()) return {};
             result.AggregateInsecure(*vec[start + j]);
         }
         return result;
@@ -686,6 +688,13 @@ CBLSPublicKey CBLSWorker::BuildPubKeyShare(const BLSVerificationVectorPtr& vvec,
 void CBLSWorker::AsyncVerifyContributionShares(const CBLSId& forId, Span<BLSVerificationVectorPtr> vvecs, Span<CBLSSecretKey> skShares,
                                                bool parallel, bool aggregated, std::function<void(const std::vector<bool>&)> doneCallback)
 {
+    if (!forId.IsValid()) {
+        std::vector<bool> result;
+        result.assign(vvecs.size(), false);
+        doneCallback(result);
+        return;
+    }
+
     // Empty input never schedules any work, so doneCallback would never fire and the
     // future-based wrappers would throw broken_promise. Mirror the empty-input
     // short-circuit in AsyncBuildQuorumVerificationVector / AsyncAggregateHelper.
@@ -693,9 +702,31 @@ void CBLSWorker::AsyncVerifyContributionShares(const CBLSId& forId, Span<BLSVeri
         doneCallback(std::vector<bool>{});
         return;
     }
-    if (!forId.IsValid() || !VerifyVerificationVectors(vvecs)) {
+
+    if (!VerifyVerificationVectors(vvecs)) {
+        // A batch-level verification-vector problem must not fail the whole batch. The
+        // only thing the batched VerifyVerificationVectors adds over the per-member
+        // VerifyVerificationVector check already run in PreVerifyMessage is detecting a
+        // coefficient point shared between two members' vvecs. Failing the whole batch on
+        // that lets one member, by placing a coefficient that collides with another
+        // member's, force every other honest member in the same verification batch to be
+        // marked invalid and complained about - a denial of service against their
+        // participation in the DKG. Instead, verify each contribution on its own: a member
+        // fails only if its own share is inconsistent with its own vvec, so a member that
+        // placed a colliding coefficient is caught on its own while the honest members it
+        // collided with verify normally.
+        LogPrint(BCLog::LLMQ_DKG, "CBLSWorker::%s -- batch verification-vector check failed; verifying %d contributions individually\n",
+                  __func__, vvecs.size());
+        std::vector<std::future<bool>> futures;
+        futures.reserve(vvecs.size());
+        for (size_t i = 0; i < vvecs.size(); i++) {
+            futures.emplace_back(AsyncVerifyContributionShare(forId, vvecs[i], skShares[i]));
+        }
         std::vector<bool> result;
-        result.assign(vvecs.size(), false);
+        result.reserve(vvecs.size());
+        for (auto& f : futures) {
+            result.push_back(f.get());
+        }
         doneCallback(result);
         return;
     }
diff --git a/src/bls/bls_worker.h b/src/bls/bls_worker.h
index 7e57df6e964c..369058a9591a 100644
--- a/src/bls/bls_worker.h
+++ b/src/bls/bls_worker.h
@@ -56,7 +56,6 @@ class CBLSWorker
 
     void Start(int16_t worker_count);
     void Stop();
-    void PushJob(std::function<void()> job);
 
 #ifndef BUILD_BITCOIN_INTERNAL
     bool GenerateContributions(int threshold, Span<CBLSId> ids, BLSVerificationVectorPtr& vvecRet, std::vector<CBLSSecretKey>& skSharesRet);
diff --git a/src/chain.h b/src/chain.h
index d3ea67d24dfa..a67a88641e9f 100644
--- a/src/chain.h
+++ b/src/chain.h
@@ -41,8 +41,8 @@ class CBlockFileInfo
 {
 public:
     unsigned int nBlocks{};      //!< number of blocks stored in file
-    unsigned int nSize{};        //!< number of used bytes of block file
-    unsigned int nUndoSize{};    //!< number of used bytes in the undo file
+    uint64_t nSize{};        //!< number of used bytes of block file
+    uint64_t nUndoSize{};    //!< number of used bytes in the undo file
     unsigned int nHeightFirst{}; //!< lowest height of block in file
     unsigned int nHeightLast{};  //!< highest height of block in file
     uint64_t nTimeFirst{};       //!< earliest time of block in file
@@ -158,10 +158,10 @@ class CBlockIndex
     int nFile GUARDED_BY(::cs_main){0};
 
     //! Byte offset within blk?????.dat where this block's data is stored
-    unsigned int nDataPos GUARDED_BY(::cs_main){0};
+    uint64_t nDataPos GUARDED_BY(::cs_main){0};
 
     //! Byte offset within rev?????.dat where this block's undo data is stored
-    unsigned int nUndoPos GUARDED_BY(::cs_main){0};
+    uint64_t nUndoPos GUARDED_BY(::cs_main){0};
 
     //! (memory only) Total amount of work (expected number of hashes) in the chain up to and including this block
     arith_uint256 nChainWork{};
diff --git a/src/flatfile.cpp b/src/flatfile.cpp
index ef8df497afaf..bee9e6d9b51c 100644
--- a/src/flatfile.cpp
+++ b/src/flatfile.cpp
@@ -45,7 +45,7 @@ FILE* FlatFileSeq::Open(const FlatFilePos& pos, bool read_only)
         LogPrintf("Unable to open file %s\n", fs::PathToString(path));
         return nullptr;
     }
-    if (pos.nPos && fseek(file, pos.nPos, SEEK_SET)) {
+    if (pos.nPos && FileSeek64(file, pos.nPos, SEEK_SET)) {
         LogPrintf("Unable to seek to position %u of %s\n", pos.nPos, fs::PathToString(path));
         fclose(file);
         return nullptr;
@@ -57,11 +57,11 @@ size_t FlatFileSeq::Allocate(const FlatFilePos& pos, size_t add_size, bool& out_
 {
     out_of_space = false;
 
-    unsigned int n_old_chunks = (pos.nPos + m_chunk_size - 1) / m_chunk_size;
-    unsigned int n_new_chunks = (pos.nPos + add_size + m_chunk_size - 1) / m_chunk_size;
+    uint64_t n_old_chunks = (pos.nPos + m_chunk_size - 1) / m_chunk_size;
+    uint64_t n_new_chunks = (pos.nPos + add_size + m_chunk_size - 1) / m_chunk_size;
     if (n_new_chunks > n_old_chunks) {
-        size_t old_size = pos.nPos;
-        size_t new_size = n_new_chunks * m_chunk_size;
+        uint64_t old_size = pos.nPos;
+        uint64_t new_size = n_new_chunks * m_chunk_size;
         size_t inc_size = new_size - old_size;
 
         if (CheckDiskSpace(m_dir, inc_size)) {
diff --git a/src/flatfile.h b/src/flatfile.h
index 44b7c5ef9f51..d35793a26e93 100644
--- a/src/flatfile.h
+++ b/src/flatfile.h
@@ -14,7 +14,7 @@
 struct FlatFilePos
 {
     int nFile{-1};
-    unsigned int nPos{0};
+    uint64_t nPos{0};
 
     SERIALIZE_METHODS(FlatFilePos, obj)
     {
@@ -23,7 +23,7 @@ struct FlatFilePos
 
     FlatFilePos() {}
 
-    FlatFilePos(int nFileIn, unsigned int nPosIn) :
+    FlatFilePos(int nFileIn, uint64_t nPosIn) :
         nFile(nFileIn),
         nPos(nPosIn)
     {}
diff --git a/src/governance/governance.cpp b/src/governance/governance.cpp
index c64fb419227a..138cd5ac8f7f 100644
--- a/src/governance/governance.cpp
+++ b/src/governance/governance.cpp
@@ -19,6 +19,7 @@
 #include <net.h>
 #include <node/interface_ui.h>
 #include <protocol.h>
+#include <random.h>
 #include <timedata.h>
 #include <util/check.h>
 #include <util/time.h>
@@ -388,6 +389,14 @@ void CGovernanceManager::AddGovernanceObjectForTesting(const CGovernanceObject&
     mapObjects.emplace(govobj.GetHash(), std::make_shared<CGovernanceObject>(govobj));
 }
 
+void CGovernanceManager::AddOrphanVoteForTesting(const CGovernanceVote& vote)
+{
+    AssertLockNotHeld(cs_store);
+    LOCK(cs_store);
+    cmmapOrphanVotes.Insert(vote.GetParentHash(),
+                            governance::OrphanVote{vote, Now<NodeSeconds>() + GOVERNANCE_ORPHAN_EXPIRATION_TIME});
+}
+
 void CGovernanceManager::CheckAndRemove()
 {
     AssertLockNotHeld(cs_store);
@@ -1159,6 +1168,12 @@ std::vector<uint256> CGovernanceManager::GetOrphanVoteObjectHashes()
         }
     }
 
+    // A random subset, so that parent hashes ground to sort first cannot pin which ones are requested
+    if (vecHashesFiltered.size() > MAX_ORPHAN_OBJECT_REQUESTS) {
+        Shuffle(vecHashesFiltered.begin(), vecHashesFiltered.end(), FastRandomContext());
+        vecHashesFiltered.resize(MAX_ORPHAN_OBJECT_REQUESTS);
+    }
+
     return vecHashesFiltered;
 }
 
diff --git a/src/governance/governance.h b/src/governance/governance.h
index 04536cb5ef04..481fc8875ebb 100644
--- a/src/governance/governance.h
+++ b/src/governance/governance.h
@@ -332,6 +332,8 @@ class CGovernanceManager : public GovernanceStore
      *  running collateral or chain validation. */
     void AddGovernanceObjectForTesting(const CGovernanceObject& govobj)
         EXCLUSIVE_LOCKS_REQUIRED(!cs_store);
+    /** Test-only helper: caches a vote as an orphan of its parent without validating it. */
+    void AddOrphanVoteForTesting(const CGovernanceVote& vote) EXCLUSIVE_LOCKS_REQUIRED(!cs_store);
 
     // Thread-safe accessors
     bool HaveObjectForHash(const uint256& nHash) const
@@ -358,7 +360,12 @@ class CGovernanceManager : public GovernanceStore
     // Used by NetGovernance
     std::vector<CInv> FetchRelayInventory() EXCLUSIVE_LOCKS_REQUIRED(!cs_relay);
     void CheckAndRemove() EXCLUSIVE_LOCKS_REQUIRED(!cs_store);
-    /** Get hashes of governance objects for which we have orphan votes. Also cleans up expired orphans. */
+    /** Upper bound on the orphan parent hashes GetOrphanVoteObjectHashes() returns per call. Each one is
+     *  re-requested from every peer, and one masternode key can sign votes for any number of invented
+     *  parent hashes. */
+    static constexpr size_t MAX_ORPHAN_OBJECT_REQUESTS{100};
+    /** Get hashes of governance objects for which we have orphan votes, at most
+     *  MAX_ORPHAN_OBJECT_REQUESTS of them chosen at random. Also cleans up expired orphans. */
     [[nodiscard]] std::vector<uint256> GetOrphanVoteObjectHashes() EXCLUSIVE_LOCKS_REQUIRED(!cs_store);
     std::pair<std::vector<uint256>, std::vector<uint256>> FetchGovernanceObjectVotes(
         size_t peers_per_hash_max, int64_t now, std::map<uint256, std::map<CService, int64_t>>& map_asked_recently) const
diff --git a/src/index/blockfilterindex.cpp b/src/index/blockfilterindex.cpp
index a2229c6667a6..3116594eb9cc 100644
--- a/src/index/blockfilterindex.cpp
+++ b/src/index/blockfilterindex.cpp
@@ -492,7 +492,7 @@ bool BlockFilterIndex::LookupFilterRange(int start_height, const CBlockIndex* st
         if (!file || entry.pos.nFile != file_num) {
             file = std::make_unique<AutoFile>(m_filter_fileseq->Open(entry.pos, true));
             file_num = entry.pos.nFile;
-        } else if (fseek(file->Get(), entry.pos.nPos, SEEK_SET) != 0) {
+        } else if (FileSeek64(file->Get(), entry.pos.nPos, SEEK_SET) != 0) {
             LogError("%s: unable to seek to position %u in filter file %d\n",
                      __func__, entry.pos.nPos, entry.pos.nFile);
             return false;
diff --git a/src/index/txindex.cpp b/src/index/txindex.cpp
index 7cb5069f43e1..000b8ebe2cc7 100644
--- a/src/index/txindex.cpp
+++ b/src/index/txindex.cpp
@@ -6,6 +6,7 @@
 
 #include <index/disktxpos.h>
 #include <node/blockstorage.h>
+#include <util/fs_helpers.h>
 #include <util/system.h>
 #include <validation.h>
 
@@ -87,7 +88,7 @@ bool TxIndex::FindTx(const uint256& tx_hash, uint256& block_hash, CTransactionRe
     CBlockHeader header;
     try {
         file >> header;
-        if (fseek(file.Get(), postx.nTxOffset, SEEK_CUR)) {
+        if (FileSeek64(file.Get(), postx.nTxOffset, SEEK_CUR)) {
             LogError("%s: fseek(...) failed\n", __func__);
             return false;
         }
diff --git a/src/interfaces/chain.h b/src/interfaces/chain.h
index fa035a627ddf..b9280d26d0de 100644
--- a/src/interfaces/chain.h
+++ b/src/interfaces/chain.h
@@ -94,7 +94,7 @@ struct BlockInfo {
     const uint256* prev_hash = nullptr;
     int height = -1;
     int file_number = -1;
-    unsigned data_pos = 0;
+    uint64_t data_pos = 0;
     const CBlock* data = nullptr;
     const CBlockUndo* undo_data = nullptr;
 
diff --git a/src/llmq/context.cpp b/src/llmq/context.cpp
index c94cf1cfa106..b961a0a7ec89 100644
--- a/src/llmq/context.cpp
+++ b/src/llmq/context.cpp
@@ -28,6 +28,5 @@ LLMQContext::LLMQContext(CDeterministicMNManager& dmnman, CEvoDB& evo_db, Chains
 
 LLMQContext::~LLMQContext()
 {
-    qman->InterruptWarming();
     bls_worker->Stop();
 }
diff --git a/src/llmq/dkgsession.cpp b/src/llmq/dkgsession.cpp
index e7a1998f8a4c..0df95d9fbd49 100644
--- a/src/llmq/dkgsession.cpp
+++ b/src/llmq/dkgsession.cpp
@@ -238,6 +238,13 @@ std::optional<CInv> CDKGSession::ReceiveMessage(const CDKGContribution& qc)
     if (!MaybeDecrypt(*qc.contributions, *myIdx, skContribution, PROTOCOL_VERSION)) {
         logger.Batch("contribution from %s could not be decrypted", member->dmn->proTxHash.ToString());
         complain = true;
+    } else if (!skContribution.IsValid()) {
+        // A decryptable but structurally-invalid (e.g. all-zero) share must never be
+        // retained: it later reaches CBLSSecretKey::AggregateInsecure() in the batched
+        // contribution verification, whose assert(IsValid()) would abort an honest node.
+        // Treat it as a bad contribution and complain.
+        logger.Batch("contribution from %s decrypted to an invalid share", member->dmn->proTxHash.ToString());
+        complain = true;
     } else if (member->idx != myIdx && ShouldSimulateError(DKGError::type::COMPLAIN_LIE)) {
         logger.Batch("lying/complaining for %s", member->dmn->proTxHash.ToString());
         complain = true;
diff --git a/src/llmq/dkgsession.h b/src/llmq/dkgsession.h
index 91b77abf1cf2..6b29c3427b0e 100644
--- a/src/llmq/dkgsession.h
+++ b/src/llmq/dkgsession.h
@@ -69,6 +69,7 @@ class DKGError {
         CONTRIBUTION_LIE,
         JUSTIFY_OMIT,
         JUSTIFY_LIE,
+        CONTRIBUTION_INVALID,
         _COUNT
     };
     static constexpr DKGError::type from_string(std::string_view in) {
@@ -79,6 +80,7 @@ class DKGError {
         if (in == "contribution-lie") return CONTRIBUTION_LIE;
         if (in == "justify-lie") return JUSTIFY_LIE;
         if (in == "justify-omit") return JUSTIFY_OMIT;
+        if (in == "contribution-invalid") return CONTRIBUTION_INVALID;
         return _COUNT;
     }
 };
diff --git a/src/llmq/net_quorum.cpp b/src/llmq/net_quorum.cpp
index 98bd4441def3..adbc2c488530 100644
--- a/src/llmq/net_quorum.cpp
+++ b/src/llmq/net_quorum.cpp
@@ -336,8 +336,11 @@ bool NetQuorum::ProcessContribQDATA(const CNode& pfrom, CDataStream& vRecv,
     std::vector<CBLSSecretKey> vecSecretKeys;
     vecSecretKeys.resize(vecEncrypted.size());
     for (const auto i : util::irange(vecEncrypted.size())) {
-        if (!m_nodeman->Decrypt(vecEncrypted[i], memberIdx, vecSecretKeys[i], PROTOCOL_VERSION)) {
-            m_peer_manager->PeerMisbehaving(pfrom.GetId(), 10, "failed to decrypt");
+        if (!m_nodeman->Decrypt(vecEncrypted[i], memberIdx, vecSecretKeys[i], PROTOCOL_VERSION) ||
+            !vecSecretKeys[i].IsValid()) {
+            // Reject an undecryptable or structurally-invalid (e.g. all-zero) share before
+            // it reaches AggregateSecretKeys()/AggregateInsecure(), which asserts validity.
+            m_peer_manager->PeerMisbehaving(pfrom.GetId(), 10, "invalid contribution share");
             return false;
         }
     }
diff --git a/src/llmq/net_signing.cpp b/src/llmq/net_signing.cpp
index 2e70d79d520b..bce2095b1c7e 100644
--- a/src/llmq/net_signing.cpp
+++ b/src/llmq/net_signing.cpp
@@ -401,7 +401,7 @@ void NetSigning::ProcessPendingSigShares(
 {
     // It's ok to perform insecure batched verification here as we verify against the quorum public key shares,
     // which are not craftable by individual entities, making the rogue public key attack impossible
-    CBLSBatchVerifier<NodeId, SigShareKey> batchVerifier(false, true);
+    SigShareBatchVerifier batchVerifier(false, true);
 
     cxxtimer::Timer prepareTimer(true);
     size_t verifyCount = 0;
@@ -432,7 +432,7 @@ void NetSigning::ProcessPendingSigShares(
                 assert(false);
             }
 
-            batchVerifier.PushMessage(nodeId, sigShare.GetKey(), sigShare.GetSignHash(), sig, pubKeyShare);
+            PushSigShareToBatchVerifier(batchVerifier, nodeId, sigShare, sig, pubKeyShare);
             verifyCount++;
         }
     }
diff --git a/src/llmq/quorumsman.cpp b/src/llmq/quorumsman.cpp
index 985aa583bbc8..92f02d9fd987 100644
--- a/src/llmq/quorumsman.cpp
+++ b/src/llmq/quorumsman.cpp
@@ -22,6 +22,7 @@
 #include <chainparams.h>
 #include <dbwrapper.h>
 #include <logging.h>
+#include <util/thread.h>
 #include <util/time.h>
 #include <validation.h>
 
@@ -41,9 +42,17 @@ CQuorumManager::CQuorumManager(CBLSWorker& _blsWorker, CDeterministicMNManager&
     AssertLockHeld(::cs_main);
     mapQuorumsCache.Init(m_chainman.GetConsensus(), /*limit_by_connections=*/false);
     MigrateOldQuorumDB(_evoDb);
+    m_cache_interrupt.reset();
+    m_cache_thread = std::thread(&util::TraceThread, "q-cache", [this] { CacheWarmingThreadMain(); });
 }
 
-CQuorumManager::~CQuorumManager() = default;
+CQuorumManager::~CQuorumManager()
+{
+    if (m_cache_thread.joinable()) {
+        m_cache_interrupt();
+        m_cache_thread.join();
+    }
+}
 
 bool CQuorumManager::GetEncryptedContributions(Consensus::LLMQType llmq_type, const CBlockIndex* block_index,
                                                const std::vector<bool>& valid_members, const uint256& protx_hash,
@@ -620,29 +629,50 @@ void CQuorumManager::WriteContributions(const CQuorumPtr& quorum) const
     quorum->WriteContributions(*db);
 }
 
-void CQuorumManager::QueueQuorumForWarming(CQuorumCPtr pQuorum) const
+void CQuorumManager::CacheWarmingThreadMain() const
 {
-    if (!pQuorum->HasVerificationVector()) {
-        return;
-    }
-    // The job may reference this manager: ~LLMQContext stops the worker pool before destroying it.
-    blsWorker.PushJob([this, pQuorum = std::move(pQuorum)]() {
+    while (!m_cache_interrupt) {
+        CQuorumCPtr pQuorum;
+        {
+            LOCK(m_cache_cs);
+            if (!m_cache_queue.empty()) {
+                pQuorum = std::move(m_cache_queue.front());
+                m_cache_queue.pop_front();
+            };
+        }
+
+        if (!pQuorum) {
+            m_cache_interrupt.sleep_for(std::chrono::milliseconds(100));
+            continue;
+        }
+
         cxxtimer::Timer t(true);
-        LogPrint(BCLog::LLMQ, "CQuorumManager::QueueQuorumForWarming -- type=%d height=%d hash=%s start\n",
+        LogPrint(BCLog::LLMQ, "CQuorumManager::%s -- type=%d height=%d hash=%s start\n", __func__,
                  std23::to_underlying(pQuorum->params.type), pQuorum->m_quorum_base_block_index->nHeight,
                  pQuorum->m_quorum_base_block_index->GetBlockHash().ToString());
+
+        // when then later some other thread tries to get keys, it will be much faster
         for (const auto i : util::irange(pQuorum->members.size())) {
-            if (m_warming_interrupted) {
-                return;
+            if (m_cache_interrupt) {
+                break;
             }
             if (pQuorum->qc->validMembers[i]) {
                 pQuorum->GetPubKeyShare(i);
             }
         }
-        LogPrint(BCLog::LLMQ, "CQuorumManager::QueueQuorumForWarming -- type=%d height=%d hash=%s done. time=%d\n",
+
+        LogPrint(BCLog::LLMQ, "CQuorumManager::%s -- type=%d height=%d hash=%s done. time=%d\n", __func__,
                  std23::to_underlying(pQuorum->params.type), pQuorum->m_quorum_base_block_index->nHeight,
                  pQuorum->m_quorum_base_block_index->GetBlockHash().ToString(), t.count());
-    });
+    }
+}
+
+void CQuorumManager::QueueQuorumForWarming(CQuorumCPtr pQuorum) const
+{
+    if (pQuorum->HasVerificationVector()) {
+        LOCK(m_cache_cs);
+        m_cache_queue.push_back(std::move(pQuorum));
+    }
 }
 
 // TODO: remove in v23
diff --git a/src/llmq/quorumsman.h b/src/llmq/quorumsman.h
index 86d06ae275d9..2955796d41f9 100644
--- a/src/llmq/quorumsman.h
+++ b/src/llmq/quorumsman.h
@@ -14,12 +14,14 @@
 #include <llmq/types.h>
 #include <saltedhasher.h>
 #include <sync.h>
+#include <util/threadinterrupt.h>
 
 #include <gsl/pointers.h>
 
-#include <atomic>
+#include <deque>
 #include <map>
 #include <memory>
+#include <thread>
 
 class CBLSSignature;
 class CBLSWorker;
@@ -94,7 +96,10 @@ class CQuorumManager final
     mutable Uint256LruHashMap<const CBlockIndex*, /*max_size=*/128> quorumBaseBlockIndexCache
         GUARDED_BY(cs_quorumBaseBlockIndexCache);
 
-    std::atomic<bool> m_warming_interrupted{false};
+    mutable Mutex m_cache_cs;
+    mutable std::deque<CQuorumCPtr> m_cache_queue GUARDED_BY(m_cache_cs);
+    mutable CThreadInterrupt m_cache_interrupt;
+    mutable std::thread m_cache_thread;
 
 public:
     CQuorumManager() = delete;
@@ -131,20 +136,20 @@ class CQuorumManager final
 
     // all these methods will lock cs_main for a short period of time
     CQuorumCPtr GetQuorum(Consensus::LLMQType llmqType, const uint256& quorumHash) const
-        EXCLUSIVE_LOCKS_REQUIRED(!cs_db, !m_cs_maps);
+        EXCLUSIVE_LOCKS_REQUIRED(!cs_db, !m_cs_maps, !m_cache_cs);
     CQuorumCPtr GetQuorum(Consensus::LLMQType llmqType, const uint256& quorumHash, const CChain& chain) const
-        EXCLUSIVE_LOCKS_REQUIRED(::cs_main, !cs_db, !m_cs_maps);
+        EXCLUSIVE_LOCKS_REQUIRED(::cs_main, !cs_db, !m_cs_maps, !m_cache_cs);
     std::vector<CQuorumCPtr> ScanQuorums(Consensus::LLMQType llmqType, size_t nCountRequested) const
-        EXCLUSIVE_LOCKS_REQUIRED(!cs_db, !m_cs_maps);
+        EXCLUSIVE_LOCKS_REQUIRED(!cs_db, !m_cs_maps, !m_cache_cs);
 
     // this one is cs_main-free
     std::vector<CQuorumCPtr> ScanQuorums(Consensus::LLMQType llmqType, gsl::not_null<const CBlockIndex*> pindexStart,
                                          size_t nCountRequested) const
-        EXCLUSIVE_LOCKS_REQUIRED(!cs_db, !m_cs_maps);
+        EXCLUSIVE_LOCKS_REQUIRED(!cs_db, !m_cs_maps, !m_cache_cs);
     std::vector<CQuorumCPtr> ScanQuorums(Consensus::LLMQType llmqType,
                                          gsl::not_null<const CBlockIndex*> pindexStart,
                                          size_t nCountRequested, const CChain& chain) const
-        EXCLUSIVE_LOCKS_REQUIRED(::cs_main, !cs_db, !m_cs_maps);
+        EXCLUSIVE_LOCKS_REQUIRED(::cs_main, !cs_db, !m_cs_maps, !m_cache_cs);
 
     std::vector<CFinalCommitment> ScanCommitments(Consensus::LLMQType llmqType, size_t nCountRequested) const
         EXCLUSIVE_LOCKS_REQUIRED(!cs_db, !m_cs_maps);
@@ -177,30 +182,29 @@ class CQuorumManager final
     CQuorumPtr GetCachedMutableQuorum(Consensus::LLMQType llmqType, const uint256& quorumHash) const
         EXCLUSIVE_LOCKS_REQUIRED(!m_cs_maps);
     void WriteContributions(const CQuorumPtr& quorum) const EXCLUSIVE_LOCKS_REQUIRED(!cs_db);
-    void QueueQuorumForWarming(CQuorumCPtr pQuorum) const;
-    /** Make queued and running warming jobs return; call before stopping the BLS worker pool */
-    void InterruptWarming() { m_warming_interrupted = true; }
+    void QueueQuorumForWarming(CQuorumCPtr pQuorum) const EXCLUSIVE_LOCKS_REQUIRED(!m_cache_cs);
 
 private:
     // all private methods here are cs_main-free
     std::vector<CQuorumCPtr> ScanQuorums(Consensus::LLMQType llmqType,
                                          gsl::not_null<const CBlockIndex*> pindexStart,
                                          size_t nCountRequested, const CChain* chain) const
-        EXCLUSIVE_LOCKS_REQUIRED(!cs_db, !m_cs_maps);
+        EXCLUSIVE_LOCKS_REQUIRED(!cs_db, !m_cs_maps, !m_cache_cs);
     bool BuildQuorumContributions(const CFinalCommitmentPtr& fqc, const std::shared_ptr<CQuorum>& quorum) const;
 
     CQuorumPtr BuildQuorumFromCommitment(Consensus::LLMQType llmqType,
                                          gsl::not_null<const CBlockIndex*> pQuorumBaseBlockIndex,
                                          bool populate_cache) const
-        EXCLUSIVE_LOCKS_REQUIRED(!cs_db, !m_cs_maps);
+        EXCLUSIVE_LOCKS_REQUIRED(!cs_db, !m_cs_maps, !m_cache_cs);
 
     CQuorumCPtr GetQuorum(Consensus::LLMQType llmqType, gsl::not_null<const CBlockIndex*> pindex,
                           bool populate_cache = true) const
-        EXCLUSIVE_LOCKS_REQUIRED(!cs_db, !m_cs_maps);
+        EXCLUSIVE_LOCKS_REQUIRED(!cs_db, !m_cs_maps, !m_cache_cs);
     CQuorumCPtr GetQuorum(Consensus::LLMQType llmqType, gsl::not_null<const CBlockIndex*> pindex,
                           const CChain& chain, bool populate_cache = true) const
-        EXCLUSIVE_LOCKS_REQUIRED(::cs_main, !cs_db, !m_cs_maps);
+        EXCLUSIVE_LOCKS_REQUIRED(::cs_main, !cs_db, !m_cs_maps, !m_cache_cs);
 
+    void CacheWarmingThreadMain() const EXCLUSIVE_LOCKS_REQUIRED(!m_cache_cs);
     void MigrateOldQuorumDB(CEvoDB& evoDb) const EXCLUSIVE_LOCKS_REQUIRED(::cs_main, !cs_db);
 };
 
diff --git a/src/llmq/signing_shares.cpp b/src/llmq/signing_shares.cpp
index 2d6bf9dac87a..cf9f62e02d1b 100644
--- a/src/llmq/signing_shares.cpp
+++ b/src/llmq/signing_shares.cpp
@@ -48,6 +48,12 @@ void CSigShare::UpdateKey()
     key.second = quorumMember;
 }
 
+void PushSigShareToBatchVerifier(SigShareBatchVerifier& batchVerifier, NodeId from, const CSigShare& sigShare,
+                                 const CBLSSignature& sig, const CBLSPublicKey& pubKeyShare)
+{
+    batchVerifier.PushMessage(from, {from, sigShare.GetKey()}, sigShare.GetSignHash(), sig, pubKeyShare);
+}
+
 std::string CSigSesAnn::ToString() const
 {
     return strprintf("sessionId=%d, llmqType=%d, quorumHash=%s, id=%s, msgHash=%s",
@@ -255,6 +261,10 @@ bool CSigSharesManager::ProcessMessageSigSesAnn(const CNode& pfrom, const CSigSe
 
     LogPrint(BCLog::LLMQ_SIGS, "CSigSharesManager::%s -- ann={%s}, node=%d\n", __func__, ann.ToString(), pfrom.GetId());
 
+    if (!IsQuorumActive(llmqType, qman, ann.getQuorumHash())) {
+        return true;
+    }
+
     auto quorum = qman.GetQuorum(llmqType, ann.getQuorumHash());
     if (!quorum) {
         // TODO should we ban here?
@@ -434,6 +444,10 @@ bool CSigSharesManager::ProcessMessageBatchedSigShares(const CNode& pfrom, const
 
 bool CSigSharesManager::ProcessMessageSigShare(NodeId fromId, const CSigShare& sigShare)
 {
+    if (!IsQuorumActive(sigShare.getLlmqType(), qman, sigShare.getQuorumHash())) {
+        return true;
+    }
+
     auto quorum = qman.GetQuorum(sigShare.getLlmqType(), sigShare.getQuorumHash());
     if (!quorum) {
         return true;
diff --git a/src/llmq/signing_shares.h b/src/llmq/signing_shares.h
index 5e885dff3ee5..509bf0366632 100644
--- a/src/llmq/signing_shares.h
+++ b/src/llmq/signing_shares.h
@@ -6,6 +6,7 @@
 #define BITCOIN_LLMQ_SIGNING_SHARES_H
 
 #include <bls/bls.h>
+#include <bls/bls_batchverifier.h>
 #include <evo/types.h>
 #include <llmq/params.h>
 #include <llmq/signhash.h>
@@ -88,6 +89,14 @@ class CSigShare : virtual public CSigBase
     }
 };
 
+// Batch entries are keyed by sender as well as SigShareKey. QSIGSHARE is accepted from any peer, so two peers can
+// push the same key; with a sender-less key the second push would alias the first entry, letting one peer's share be
+// judged in place of the other's (banning an honest sender, or never checking a forged share).
+using SigShareBatchVerifier = CBLSBatchVerifier<NodeId, std::pair<NodeId, SigShareKey>>;
+
+void PushSigShareToBatchVerifier(SigShareBatchVerifier& batchVerifier, NodeId from, const CSigShare& sigShare,
+                                 const CBLSSignature& sig, const CBLSPublicKey& pubKeyShare);
+
 // Nodes will first announce a signing session with a sessionId to be used in all future P2P messages related to that
 // session. We locally keep track of the mapping for each node. We also assign new sessionIds for outgoing sessions
 // and send QSIGSESANN messages appropriately. All values except the max value for uint32_t are valid as sessionId
diff --git a/src/masternode/meta.cpp b/src/masternode/meta.cpp
index 2c7a67e0d221..d1a37f3d5f44 100644
--- a/src/masternode/meta.cpp
+++ b/src/masternode/meta.cpp
@@ -200,11 +200,10 @@ bool CMasternodeMetaMan::SetPlatformBan(const uint256& inv_hash, PlatformBanMess
 
     const uint256& protx_hash = ban_msg.m_protx_hash;
 
-    bool ret = GetMetaInfo(protx_hash).SetPlatformBan(true, ban_msg.m_requested_height);
-    if (ret) {
-        m_seen_platform_bans.emplace(inv_hash, std::move(ban_msg));
-    }
-    return ret;
+    const bool changed = GetMetaInfo(protx_hash).SetPlatformBan(true, ban_msg.m_requested_height);
+    // Remember authenticated messages even when newer metadata supersedes them.
+    m_seen_platform_bans.emplace(inv_hash, std::move(ban_msg));
+    return changed;
 }
 
 bool CMasternodeMetaMan::AlreadyHavePlatformBan(const uint256& inv_hash) const
diff --git a/src/masternode/meta.h b/src/masternode/meta.h
index 2e51680b740a..552ff2d14e62 100644
--- a/src/masternode/meta.h
+++ b/src/masternode/meta.h
@@ -75,7 +75,7 @@ class CMasternodeMetaInfo
         if (height < m_platform_ban_updated) {
             return false;
         }
-        if (height == m_platform_ban_updated && !is_banned) {
+        if (height == m_platform_ban_updated && (!is_banned || m_platform_ban)) {
             return false;
         }
         m_platform_ban = is_banned;
diff --git a/src/net.cpp b/src/net.cpp
index 4e9d3457cb7f..38ba21d4b13b 100644
--- a/src/net.cpp
+++ b/src/net.cpp
@@ -1762,7 +1762,11 @@ std::pair<size_t, bool> CConnman::SocketSendData(CNode& node) const
         }
     }
 
-    node.fPauseSend = node.m_send_memusage + node.m_transport->GetSendMemoryUsage() > nSendBufferMaxSize;
+    const bool pause_send{node.m_send_memusage + node.m_transport->GetSendMemoryUsage() > nSendBufferMaxSize};
+    if (pause_send && !node.fPauseSend) {
+        node.m_pause_send_since = GetTime<std::chrono::seconds>();
+    }
+    node.fPauseSend = pause_send;
 
     if (it == node.vSendMsg.end()) {
         assert(node.m_send_memusage == 0);
@@ -2320,6 +2324,14 @@ bool CConnman::InactivityCheck(const CNode& node) const
         return true;
     }
 
+    if (node.fPauseSend) {
+        const auto last_pause{node.m_pause_send_since.load()};
+        if (now > last_pause + TIMEOUT_INTERVAL) {
+            LogPrint(BCLog::NET, "send buffer full for %is peer=%d\n", count_seconds(now - last_pause), node.GetId());
+            return true;
+        }
+    }
+
     if (!node.fSuccessfullyConnected) {
         if (node.m_transport->GetInfo().transport_type == TransportProtocolType::DETECTING) {
             LogPrint(BCLog::NET, "V2 handshake timeout peer=%d\n", node.GetId());
@@ -2341,7 +2353,7 @@ Sock::EventsPerSock CConnman::GenerateWaitSockets(Span<CNode* const> nodes)
     }
 
     for (CNode* pnode : nodes) {
-        bool select_recv = !pnode->fHasRecvData;
+        bool select_recv = !pnode->fHasRecvData && !pnode->fPauseRecv;
         bool select_send = !pnode->fCanSendData;
         if (!select_recv && !select_send) continue;
 
@@ -4885,7 +4897,10 @@ void CConnman::PushMessage(CNode* pnode, CSerializedNetMsg&& msg)
 
         // Update memory usage of send buffer.
         pnode->m_send_memusage += msg.GetMemoryUsage();
-        if (pnode->m_send_memusage + pnode->m_transport->GetSendMemoryUsage() > nSendBufferMaxSize) pnode->fPauseSend = true;
+        if (pnode->m_send_memusage + pnode->m_transport->GetSendMemoryUsage() > nSendBufferMaxSize && !pnode->fPauseSend) {
+            pnode->m_pause_send_since = GetTime<std::chrono::seconds>();
+            pnode->fPauseSend = true;
+        }
         // Move message to vSendMsg queue.
         pnode->vSendMsg.push_back(std::move(msg));
         pnode->nSendMsgSize = pnode->vSendMsg.size();
diff --git a/src/net.h b/src/net.h
index 3b1ded7de0fb..c23545887849 100644
--- a/src/net.h
+++ b/src/net.h
@@ -828,6 +828,8 @@ class CNode
 
     std::atomic_bool fPauseRecv{false};
     std::atomic_bool fPauseSend{false};
+    /** When was fPauseSend last set from false to true */
+    std::atomic<std::chrono::seconds> m_pause_send_since{0s};
 
     std::atomic_bool fHasRecvData{false};
     std::atomic_bool fCanSendData{false};
diff --git a/src/net_processing.cpp b/src/net_processing.cpp
index c41876bc606c..93754ee7d20b 100644
--- a/src/net_processing.cpp
+++ b/src/net_processing.cpp
@@ -3850,14 +3850,18 @@ MessageProcessingResult PeerManagerImpl::ProcessPlatformBanMessage(NodeId node,
 
     const uint256 hash = ban_msg.GetHash();
 
-    LogPrintf("PLATFORMBAN -- hash: %s protx_hash: %s height: %d peer=%d\n", hash.ToString(), ban_msg.m_protx_hash.ToString(), ban_msg.m_requested_height, node);
-
     // NOTE: deliberately no solicitation gate here, unlike the other GETDATA-only object types.
     // PLATFORMBAN has no local ingress (no RPC, no internal producer): the originating Dash
     // Platform node injects the ban by pushing the message straight to a Dash Core peer, so the
     // first hop is always unsolicited by design. See p2p_platform_ban.py.
     MessageProcessingResult ret{};
     ret.m_to_erase = CInv{MSG_PLATFORM_BAN, hash};
+    if (m_mn_metaman.AlreadyHavePlatformBan(hash)) {
+        return ret;
+    }
+
+    LogPrintf("PLATFORMBAN -- hash: %s protx_hash: %s height: %d peer=%d\n", hash.ToString(),
+              ban_msg.m_protx_hash.ToString(), ban_msg.m_requested_height, node);
 
     const auto list = m_dmnman.GetListAtChainTip();
     auto dmn = list.GetMN(ban_msg.m_protx_hash);
diff --git a/src/node/blockstorage.cpp b/src/node/blockstorage.cpp
index 1f2680fa0a6c..ff04bdb8ab2a 100644
--- a/src/node/blockstorage.cpp
+++ b/src/node/blockstorage.cpp
@@ -15,6 +15,7 @@
 #include <streams.h>
 #include <undo.h>
 #include <util/fs.h>
+#include <util/fs_helpers.h>
 #include <util/system.h>
 #include <validation.h>
 #include <walletinitinterface.h>
@@ -520,12 +521,12 @@ static bool UndoWriteToDisk(const CBlockUndo& blockundo, FlatFilePos& pos, const
     fileout << messageStart << nSize;
 
     // Write undo data
-    long fileOutPos = ftell(fileout.Get());
+    const int64_t fileOutPos{FileTell64(fileout.Get())};
     if (fileOutPos < 0) {
         LogError("%s: ftell failed\n", __func__);
         return false;
     }
-    pos.nPos = (unsigned int)fileOutPos;
+    pos.nPos = fileOutPos;
     fileout << blockundo;
 
     // calculate & write checksum
@@ -759,12 +760,12 @@ static bool WriteBlockToDisk(const CBlock& block, FlatFilePos& pos, const CMessa
     fileout << messageStart << nSize;
 
     // Write block
-    long fileOutPos = ftell(fileout.Get());
+    const int64_t fileOutPos{FileTell64(fileout.Get())};
     if (fileOutPos < 0) {
         LogError("WriteBlockToDisk: ftell failed\n");
         return false;
     }
-    pos.nPos = (unsigned int)fileOutPos;
+    pos.nPos = fileOutPos;
     fileout << block;
 
     return true;
diff --git a/src/primitives/transaction.h b/src/primitives/transaction.h
index 14ae6d160349..f289c75cefaf 100644
--- a/src/primitives/transaction.h
+++ b/src/primitives/transaction.h
@@ -232,6 +232,13 @@ inline CAmount CalculateOutputValue(const TxType& tx)
 }
 
 
+/** nVersion and nType share one 32-bit wire field. nVersion fills the low half as raw bits:
+ *  sign-extending a negative nVersion would overwrite nType. */
+constexpr int32_t PackVersionAndType(int16_t nVersion, uint16_t nType)
+{
+    return static_cast<int32_t>(static_cast<uint16_t>(nVersion) | (static_cast<uint32_t>(nType) << 16));
+}
+
 /** The basic transaction that is broadcasted on the network and contained in
  * blocks.  A transaction can contain multiple inputs and outputs.
  */
@@ -268,7 +275,7 @@ class CTransaction
 
     template <typename Stream>
     inline void Serialize(Stream& s) const {
-        int32_t n32bitVersion = this->nVersion | (this->nType << 16);
+        int32_t n32bitVersion = PackVersionAndType(this->nVersion, this->nType);
         s << n32bitVersion;
         s << vin;
         s << vout;
@@ -354,7 +361,7 @@ struct CMutableTransaction
     SERIALIZE_METHODS(CMutableTransaction, obj)
     {
         int32_t n32bitVersion;
-        SER_WRITE(obj, n32bitVersion = obj.nVersion | (obj.nType << 16));
+        SER_WRITE(obj, n32bitVersion = PackVersionAndType(obj.nVersion, obj.nType));
         READWRITE(n32bitVersion);
         SER_READ(obj, obj.nVersion = (int16_t) (n32bitVersion & 0xffff));
         SER_READ(obj, obj.nType = (uint16_t) ((n32bitVersion >> 16) & 0xffff));
diff --git a/src/script/interpreter.cpp b/src/script/interpreter.cpp
index 4c129a5c9b95..f997090edd62 100644
--- a/src/script/interpreter.cpp
+++ b/src/script/interpreter.cpp
@@ -1063,11 +1063,7 @@ bool EvalScript(std::vector<std::vector<unsigned char> >& stack, const CScript&
 
                     bool fSuccess = false;
                     if (vchSig.size()) {
-                        valtype vchHash(32);
-                        CSHA256()
-                            .Write(vchMessage.data(), vchMessage.size())
-                            .Finalize(vchHash.data());
-                        fSuccess = CPubKey(vchPubKey).Verify(uint256(vchHash), vchSig);
+                        fSuccess = checker.CheckDataSig(vchSig, vchMessage, vchPubKey);
                     }
 
                     if (!fSuccess && (flags & SCRIPT_VERIFY_NULLFAIL) && vchSig.size()) {
@@ -1420,7 +1416,7 @@ class CTransactionSignatureSerializer
     template<typename S>
     void Serialize(S &s) const {
         // Serialize nVersion
-        int32_t n32bitVersion = txTo.nVersion | (txTo.nType << 16);
+        int32_t n32bitVersion = PackVersionAndType(txTo.nVersion, txTo.nType);
         ::Serialize(s, n32bitVersion);
         // Serialize vin
         unsigned int nInputs = fAnyoneCanPay ? 1 : txTo.vin.size();
@@ -1533,12 +1529,37 @@ uint256 SignatureHash(const CScript& scriptCode, const T& txTo, unsigned int nIn
 template uint256 SignatureHash<CMutableTransaction>(const CScript& scriptCode, const CMutableTransaction& txTo, unsigned int nIn, int nHashType, const CAmount& amount, SigVersion sigversion, const PrecomputedTransactionData* cache);
 template uint256 SignatureHash<CTransaction>(const CScript& scriptCode, const CTransaction& txTo, unsigned int nIn, int nHashType, const CAmount& amount, SigVersion sigversion, const PrecomputedTransactionData* cache);
 
+static uint256 DataSignatureHash(const std::vector<unsigned char>& vchMessage)
+{
+    uint256 hash;
+    CSHA256().Write(vchMessage.data(), vchMessage.size()).Finalize(hash.begin());
+    return hash;
+}
+
+bool BaseSignatureChecker::CheckDataSig(const std::vector<unsigned char>& vchSig, const std::vector<unsigned char>& vchMessage,
+                                        const std::vector<unsigned char>& vchPubKey) const
+{
+    return CPubKey(vchPubKey).Verify(DataSignatureHash(vchMessage), vchSig);
+}
+
 template <class T>
 bool GenericTransactionSignatureChecker<T>::VerifySignature(const std::vector<unsigned char>& vchSig, const CPubKey& pubkey, const uint256& sighash) const
 {
     return pubkey.Verify(sighash, vchSig);
 }
 
+template <class T>
+bool GenericTransactionSignatureChecker<T>::CheckDataSig(const std::vector<unsigned char>& vchSig,
+                                                         const std::vector<unsigned char>& vchMessage,
+                                                         const std::vector<unsigned char>& vchPubKey) const
+{
+    // An invalid key serializes to no bytes in the signature cache entry, so it must not reach the cache
+    const CPubKey pubkey(vchPubKey);
+    if (!pubkey.IsValid()) return false;
+    // Through the virtual VerifySignature, so CachingTransactionSignatureChecker caches the result
+    return VerifySignature(vchSig, pubkey, DataSignatureHash(vchMessage));
+}
+
 template <class T>
 bool GenericTransactionSignatureChecker<T>::CheckSig(const std::vector<unsigned char>& vchSigIn, const std::vector<unsigned char>& vchPubKey, const CScript& scriptCode, SigVersion sigversion) const
 {
diff --git a/src/script/interpreter.h b/src/script/interpreter.h
index df0b1548f414..e6ec7d3392aa 100644
--- a/src/script/interpreter.h
+++ b/src/script/interpreter.h
@@ -156,6 +156,10 @@ class BaseSignatureChecker
          return false;
     }
 
+    /** Verify vchSig as an ECDSA signature by vchPubKey over SHA256(vchMessage), as CHECKDATASIG does */
+    virtual bool CheckDataSig(const std::vector<unsigned char>& vchSig, const std::vector<unsigned char>& vchMessage,
+                              const std::vector<unsigned char>& vchPubKey) const;
+
     virtual ~BaseSignatureChecker() {}
 };
 
@@ -187,6 +191,8 @@ class GenericTransactionSignatureChecker : public BaseSignatureChecker
     bool CheckSig(const std::vector<unsigned char>& scriptSig, const std::vector<unsigned char>& vchPubKey, const CScript& scriptCode, SigVersion sigversion) const override;
     bool CheckLockTime(const CScriptNum& nLockTime) const override;
     bool CheckSequence(const CScriptNum& nSequence) const override;
+    bool CheckDataSig(const std::vector<unsigned char>& vchSig, const std::vector<unsigned char>& vchMessage,
+                      const std::vector<unsigned char>& vchPubKey) const override;
 };
 
 using TransactionSignatureChecker = GenericTransactionSignatureChecker<CTransaction>;
@@ -212,6 +218,11 @@ class DeferringSignatureChecker : public BaseSignatureChecker
     {
         return m_checker.CheckSequence(nSequence);
     }
+    bool CheckDataSig(const std::vector<unsigned char>& vchSig, const std::vector<unsigned char>& vchMessage,
+                      const std::vector<unsigned char>& vchPubKey) const override
+    {
+        return m_checker.CheckDataSig(vchSig, vchMessage, vchPubKey);
+    }
 };
 
 bool EvalScript(std::vector<std::vector<unsigned char> >& stack, const CScript& script, unsigned int flags, const BaseSignatureChecker& checker, SigVersion sigversion, ScriptError* error = nullptr);
diff --git a/src/streams.cpp b/src/streams.cpp
index 6921dad67733..98e29cd4d0ed 100644
--- a/src/streams.cpp
+++ b/src/streams.cpp
@@ -4,6 +4,7 @@
 
 #include <span.h>
 #include <streams.h>
+#include <util/fs_helpers.h>
 
 #include <array>
 
@@ -13,7 +14,7 @@ std::size_t AutoFile::detail_fread(Span<std::byte> dst)
     if (m_xor.empty()) {
         return std::fread(dst.data(), 1, dst.size(), m_file);
     } else {
-        const auto init_pos{std::ftell(m_file)};
+        const auto init_pos{FileTell64(m_file)};
         if (init_pos < 0) throw std::ios_base::failure("AutoFile::read: ftell failed");
         std::size_t ret{std::fread(dst.data(), 1, dst.size(), m_file)};
         util::Xor(dst.subspan(0, ret), m_xor, init_pos);
@@ -49,7 +50,7 @@ void AutoFile::write(Span<const std::byte> src)
             throw std::ios_base::failure("AutoFile::write: write failed");
         }
     } else {
-        auto current_pos{std::ftell(m_file)};
+        auto current_pos{FileTell64(m_file)};
         if (current_pos < 0) throw std::ios_base::failure("AutoFile::write: ftell failed");
         std::array<std::byte, 4096> buf;
         while (src.size() > 0) {
diff --git a/src/test/bls_tests.cpp b/src/test/bls_tests.cpp
index 5696a34273ff..3abcb14611f5 100644
--- a/src/test/bls_tests.cpp
+++ b/src/test/bls_tests.cpp
@@ -7,6 +7,7 @@
 #include <bls/bls_worker.h>
 #include <clientversion.h>
 #include <consensus/validation.h>
+#include <crypto/common.h>
 #include <deploymentstatus.h>
 #include <random.h>
 #include <script/standard.h>
@@ -644,6 +645,64 @@ BOOST_AUTO_TEST_CASE(bls_verify_contribution_shares_honest_tests)
     FuncVerifyContributionSharesHonest(false);
 }
 
+// A duplicate coefficient point between two members' verification vectors must not fail the
+// other members' contributions. CBLSWorker::VerifyContributionShares() batches the members'
+// vvecs, and the batched VerifyVerificationVectors() check rejects a coefficient shared
+// between two vvecs. Failing the whole batch on that let one member, by copying another
+// member's coefficient into its own vvec, mark every honest member in the batch invalid.
+// The fix verifies each contribution against its own vvec, so only the member whose share no
+// longer matches its own vvec fails. Regression: on the old all-or-nothing code every entry
+// came back false, so the honest members verifying true is what distinguishes fixed from broken.
+void FuncVerifyContributionSharesDuplicateCoefficient(const bool legacy_scheme)
+{
+    bls::bls_legacy_scheme.store(legacy_scheme);
+
+    CBLSWorker worker;
+    worker.Start(4);
+
+    const int threshold = 2;
+    std::vector<CBLSId> ids;
+    for (int i = 0; i < 4; i++) {
+        uint256 id;
+        WriteLE64(id.begin(), i + 1);
+        ids.emplace_back(id);
+    }
+
+    // Three dealers each generate a verification vector and their secret-key shares to each id.
+    std::vector<BLSVerificationVectorPtr> vvecs(3);
+    std::vector<std::vector<CBLSSecretKey>> skShares(3);
+    for (int d = 0; d < 3; d++) {
+        BOOST_REQUIRE(worker.GenerateContributions(threshold, ids, vvecs[d], skShares[d]));
+    }
+
+    // Receiver R collects each dealer's share to it.
+    const size_t R = 0;
+    const CBLSId& recvId = ids[R];
+    std::vector<CBLSSecretKey> recvShares{skShares[0][R], skShares[1][R], skShares[2][R]};
+
+    // All honest: every contribution verifies.
+    std::vector<bool> ok = worker.VerifyContributionShares(recvId, vvecs, recvShares);
+    BOOST_REQUIRE_EQUAL(ok.size(), 3U);
+    BOOST_CHECK(ok[0] && ok[1] && ok[2]);
+
+    // Dealer 0 copies dealer 1's leading coefficient into its own vvec (a cross-member
+    // duplicate) without touching its share, making the batch vvec check fail.
+    vvecs[0]->at(0) = vvecs[1]->at(0);
+    std::vector<bool> res = worker.VerifyContributionShares(recvId, vvecs, recvShares);
+    BOOST_REQUIRE_EQUAL(res.size(), 3U);
+    BOOST_CHECK(!res[0]);  // the member that planted the duplicate is caught alone
+    BOOST_CHECK(res[1]);   // the honest member whose coefficient was copied is unaffected
+    BOOST_CHECK(res[2]);   // the other honest member is unaffected
+
+    worker.Stop();
+}
+
+BOOST_AUTO_TEST_CASE(bls_verify_contribution_shares_duplicate_coefficient_tests)
+{
+    FuncVerifyContributionSharesDuplicateCoefficient(true);
+    FuncVerifyContributionSharesDuplicateCoefficient(false);
+}
+
 // A dummy BLS object that satisfies the minimal interface expected by CBLSLazyWrapper.
 class DummyBLS
 {
diff --git a/src/test/checkdatasig_tests.cpp b/src/test/checkdatasig_tests.cpp
index 70e4544fc4a6..231d4323d8ee 100644
--- a/src/test/checkdatasig_tests.cpp
+++ b/src/test/checkdatasig_tests.cpp
@@ -3,7 +3,9 @@
 // file COPYING or http://www.opensource.org/licenses/mit-license.php.
 
 #include <policy/policy.h>
+#include <primitives/transaction.h>
 #include <script/interpreter.h>
+#include <script/sigcache.h>
 
 #include <test/lcg.h>
 #include <test/util/setup_common.h>
@@ -11,6 +13,7 @@
 #include <boost/test/unit_test.hpp>
 
 #include <array>
+#include <functional>
 
 typedef std::vector<uint8_t> valtype;
 typedef std::vector<valtype> stacktype;
@@ -36,27 +39,46 @@ struct KeyData {
     }
 };
 
+static CMutableTransaction SpendingTx()
+{
+    CMutableTransaction tx;
+    tx.vin.resize(1);
+    return tx;
+}
+
+//! Data signatures must behave the same with the plain, transaction and caching signature checkers
+static void ForEachChecker(const std::function<void(const BaseSignatureChecker&)>& check)
+{
+    const CTransaction tx{SpendingTx()};
+    PrecomputedTransactionData txdata;
+    check(BaseSignatureChecker{});
+    check(TransactionSignatureChecker{&tx, 0, 0, MissingDataBehavior::FAIL});
+    check(CachingTransactionSignatureChecker{&tx, 0, 0, txdata, /*storeIn=*/true});
+}
+
 static void CheckError(uint32_t flags, const stacktype& original_stack,
                        const CScript& script, ScriptError expected)
 {
-    BaseSignatureChecker sigchecker;
-    ScriptError err = ScriptError::SCRIPT_ERR_OK;
-    stacktype stack{original_stack};
-    bool r = EvalScript(stack, script, flags, sigchecker, SigVersion::BASE, &err);
-    BOOST_CHECK(!r);
-    BOOST_CHECK(err == expected);
+    ForEachChecker([&](const BaseSignatureChecker& sigchecker) {
+        ScriptError err = ScriptError::SCRIPT_ERR_OK;
+        stacktype stack{original_stack};
+        bool r = EvalScript(stack, script, flags, sigchecker, SigVersion::BASE, &err);
+        BOOST_CHECK(!r);
+        BOOST_CHECK(err == expected);
+    });
 }
 
 static void CheckPass(uint32_t flags, const stacktype& original_stack,
                       const CScript& script, const stacktype& expected)
 {
-    BaseSignatureChecker sigchecker;
-    ScriptError err = ScriptError::SCRIPT_ERR_OK;
-    stacktype stack{original_stack};
-    bool r = EvalScript(stack, script, flags, sigchecker, SigVersion::BASE, &err);
-    BOOST_CHECK(r);
-    BOOST_CHECK(err == ScriptError::SCRIPT_ERR_OK);
-    BOOST_CHECK(stack == expected);
+    ForEachChecker([&](const BaseSignatureChecker& sigchecker) {
+        ScriptError err = ScriptError::SCRIPT_ERR_OK;
+        stacktype stack{original_stack};
+        bool r = EvalScript(stack, script, flags, sigchecker, SigVersion::BASE, &err);
+        BOOST_CHECK(r);
+        BOOST_CHECK(err == ScriptError::SCRIPT_ERR_OK);
+        BOOST_CHECK(stack == expected);
+    });
 }
 
 /**
@@ -230,4 +252,55 @@ BOOST_AUTO_TEST_CASE(checkdatasig_test)
     }
 }
 
+static uint256 MessageHash(const valtype& message)
+{
+    uint256 hash;
+    CSHA256().Write(message.data(), message.size()).Finalize(hash.begin());
+    return hash;
+}
+
+// A cached valid data signature must not validate a different message, key or signature.
+BOOST_AUTO_TEST_CASE(checkdatasig_signature_cache_controls)
+{
+    KeyData kd;
+    const valtype message{0x03, 0x04};
+    valtype sig;
+    BOOST_REQUIRE(kd.privkeyC.Sign(MessageHash(message), sig));
+    const valtype pubkey{ToByteVector(kd.pubkeyC)};
+    CKey other_key;
+    other_key.MakeNewKey(/*fCompressed=*/true);
+    valtype bad_sig{sig};
+    bad_sig[bad_sig.size() - 1] ^= 0x01;
+
+    const CTransaction tx{SpendingTx()};
+    PrecomputedTransactionData txdata;
+    const CachingTransactionSignatureChecker storing{&tx, 0, 0, txdata, /*storeIn=*/true};
+    const CachingTransactionSignatureChecker lookup{&tx, 0, 0, txdata, /*storeIn=*/false};
+    const auto result = [](const BaseSignatureChecker& checker, const stacktype& args) {
+        stacktype stack{args};
+        ScriptError err;
+        BOOST_REQUIRE(EvalScript(stack, CScript() << OP_CHECKDATASIG, SCRIPT_VERIFY_NONE, checker, SigVersion::BASE, &err));
+        return stack == stacktype{{0x01}};
+    };
+
+    BOOST_CHECK(result(storing, {sig, message, pubkey}));
+    BOOST_CHECK(result(lookup, {sig, message, pubkey}));
+    BOOST_CHECK(!result(lookup, {sig, {0x03, 0x05}, pubkey}));
+    BOOST_CHECK(!result(lookup, {sig, message, ToByteVector(other_key.GetPubKey())}));
+    BOOST_CHECK(!result(lookup, {bad_sig, message, pubkey}));
+    BOOST_CHECK(!result(storing, {bad_sig, message, pubkey}));
+    BOOST_CHECK(!result(lookup, {bad_sig, message, pubkey}));
+
+    // An invalid public key adds no bytes to a cache entry, so moving the key into the signature must
+    // not match the cached (message, key, signature) entry
+    valtype alias{pubkey};
+    alias.insert(alias.end(), sig.begin(), sig.end());
+    for (const valtype& invalid_pubkey : {valtype{}, valtype{0x02}, valtype(pubkey.begin(), pubkey.end() - 1)}) {
+        // A lookup-only hit marks its entry discardable, so store the valid one again to keep it
+        BOOST_REQUIRE(result(storing, {sig, message, pubkey}));
+        BOOST_CHECK(!result(storing, {alias, message, invalid_pubkey}));
+        BOOST_CHECK(!result(lookup, {alias, message, invalid_pubkey}));
+    }
+}
+
 BOOST_AUTO_TEST_SUITE_END()
diff --git a/src/test/governance_inv_tests.cpp b/src/test/governance_inv_tests.cpp
index 880670bf862d..13a2c0c5f7c6 100644
--- a/src/test/governance_inv_tests.cpp
+++ b/src/test/governance_inv_tests.cpp
@@ -26,9 +26,11 @@
 
 #include <boost/test/unit_test.hpp>
 
+#include <algorithm>
 #include <atomic>
 #include <chrono>
 #include <memory>
+#include <set>
 #include <vector>
 
 using namespace std::chrono_literals;
@@ -550,4 +552,36 @@ BOOST_AUTO_TEST_CASE(invalid_vote_is_scored_alike_with_and_without_a_parent_obje
     chainstate.ResetIbd();
 }
 
+// Every orphan parent hash is re-requested from every peer on each governance tick, and one
+// masternode key can sign votes for any number of invented parents, so the hashes requested per tick
+// must stay bounded.
+BOOST_AUTO_TEST_CASE(orphan_object_requests_are_capped_per_tick)
+{
+    constexpr size_t cap{CGovernanceManager::MAX_ORPHAN_OBJECT_REQUESTS};
+    std::set<uint256> parents;
+    const auto add_orphans = [&](size_t count) {
+        for (size_t i = 0; i < count; ++i) {
+            const uint256 parent{GetRandHash()};
+            parents.insert(parent);
+            m_node.govman->AddOrphanVoteForTesting(MakeGovernanceVote(parent));
+        }
+    };
+
+    // Up to the cap, every orphan parent is requested.
+    add_orphans(cap);
+    auto hashes{m_node.govman->GetOrphanVoteObjectHashes()};
+    BOOST_CHECK(std::set<uint256>(hashes.begin(), hashes.end()) == parents);
+
+    // Beyond it, each tick requests exactly cap distinct ones among them.
+    add_orphans(cap);
+    for (int tick = 0; tick < 2; ++tick) {
+        hashes = m_node.govman->GetOrphanVoteObjectHashes();
+        BOOST_CHECK_EQUAL(hashes.size(), cap);
+        const std::set<uint256> unique(hashes.begin(), hashes.end());
+        BOOST_CHECK_EQUAL(unique.size(), cap);
+        BOOST_CHECK(std::includes(parents.begin(), parents.end(), unique.begin(), unique.end()));
+    }
+}
+
+
 BOOST_AUTO_TEST_SUITE_END()
diff --git a/src/test/llmq_utils_tests.cpp b/src/test/llmq_utils_tests.cpp
index bfee20443afd..31b10acb789c 100644
--- a/src/test/llmq_utils_tests.cpp
+++ b/src/test/llmq_utils_tests.cpp
@@ -5,6 +5,7 @@
 #include <test/util/llmq_tests.h>
 #include <test/util/setup_common.h>
 
+#include <bls/bls.h>
 #include <chainparams.h>
 #include <consensus/params.h>
 #include <dbwrapper.h>
@@ -23,6 +24,7 @@
 
 #include <map>
 #include <set>
+#include <vector>
 
 using namespace llmq;
 using namespace llmq::testutils;
@@ -259,6 +261,47 @@ BOOST_AUTO_TEST_CASE(pending_sig_shares_session_removal_updates_count)
     BOOST_CHECK_EQUAL(node_state.pendingIncomingSigShares.Size(), 1U);
 }
 
+BOOST_AUTO_TEST_CASE(sig_share_batch_verifier_judges_each_sender_by_its_own_share)
+{
+    const bool legacy_scheme{bls::bls_legacy_scheme.load()};
+    const CSigShare sig_share{MakeSigShare(1)};
+
+    CBLSSecretKey sk_share;
+    sk_share.MakeNewKey();
+    const CBLSPublicKey pk_share{sk_share.GetPublicKey()};
+    const CBLSSignature valid_sig{sk_share.Sign(sig_share.GetSignHash(), legacy_scheme)};
+
+    CBLSSecretKey sk_forger;
+    sk_forger.MakeNewKey();
+    const CBLSSignature forged_sig{sk_forger.Sign(sig_share.GetSignHash(), legacy_scheme)};
+
+    constexpr NodeId honest{1};
+    constexpr NodeId attacker{2};
+    constexpr NodeId other_honest{3};
+
+    struct Push {
+        NodeId from;
+        CBLSSignature sig;
+    };
+    const std::vector<std::pair<std::vector<Push>, std::set<NodeId>>> cases{
+        // Honest share first: the forged copy of the same key must still be checked, not shadowed.
+        {{{honest, valid_sig}, {attacker, forged_sig}}, {attacker}},
+        // Forged share first: the honest sender must be judged by its own share, not the attacker's.
+        {{{attacker, forged_sig}, {honest, valid_sig}}, {attacker}},
+        // The same valid share relayed by two peers is not misbehavior.
+        {{{honest, valid_sig}, {other_honest, valid_sig}}, {}},
+    };
+
+    for (const auto& [pushes, expected_bad_sources] : cases) {
+        SigShareBatchVerifier verifier(/*_secureVerification=*/false, /*_perMessageFallback=*/true);
+        for (const auto& push : pushes) {
+            PushSigShareToBatchVerifier(verifier, push.from, sig_share, push.sig, pk_share);
+        }
+        verifier.Verify();
+        BOOST_CHECK(verifier.badSources == expected_bad_sources);
+    }
+}
+
 BOOST_AUTO_TEST_CASE(batched_sig_shares_rejects_oversized_inner_vector)
 {
     CDataStream stream{SER_NETWORK, PROTOCOL_VERSION};
diff --git a/src/test/sighash_tests.cpp b/src/test/sighash_tests.cpp
index 51a92809acc1..1f7b4502776b 100644
--- a/src/test/sighash_tests.cpp
+++ b/src/test/sighash_tests.cpp
@@ -90,7 +90,7 @@ void static RandomScript(CScript &script) {
 
 void static RandomTransaction(CMutableTransaction &tx, bool fSingle)
 {
-    tx.nVersion = int(InsecureRandRange(2)) + 1;
+    tx.nVersion = static_cast<int16_t>(InsecureRandBits(16));
     tx.vin.clear();
     tx.vout.clear();
     tx.nLockTime = (InsecureRandBool()) ? InsecureRand32() : 0;
diff --git a/src/test/transaction_tests.cpp b/src/test/transaction_tests.cpp
index 27c1c406a1c6..17cc08a4fa95 100644
--- a/src/test/transaction_tests.cpp
+++ b/src/test/transaction_tests.cpp
@@ -333,6 +333,26 @@ BOOST_AUTO_TEST_CASE(basic_transaction_tests)
     BOOST_CHECK_MESSAGE(!CheckTransaction(CTransaction(tx), state) || !state.IsValid(), "Transaction with duplicate txins should be invalid.");
 }
 
+BOOST_AUTO_TEST_CASE(tx_version_type_roundtrip)
+{
+    // nVersion and nType share one 32-bit wire field; a negative nVersion must not sign-extend over nType
+    for (const auto& [version, type] : std::vector<std::pair<int16_t, uint16_t>>{{-1, TRANSACTION_NORMAL}, {-1, 0xffff}}) {
+        CMutableTransaction tx;
+        tx.nVersion = version;
+        tx.nType = type;
+        CDataStream mutable_stream(SER_NETWORK, PROTOCOL_VERSION);
+        mutable_stream << tx;
+        CDataStream stream(SER_NETWORK, PROTOCOL_VERSION);
+        stream << CTransaction(tx);
+        BOOST_CHECK_EQUAL(HexStr(stream), HexStr(mutable_stream));
+
+        CMutableTransaction tx_read;
+        stream >> tx_read;
+        BOOST_CHECK_EQUAL(tx_read.nVersion, version);
+        BOOST_CHECK_EQUAL(tx_read.nType, type);
+    }
+}
+
 BOOST_AUTO_TEST_CASE(test_Get)
 {
     FillableSigningProvider keystore;
diff --git a/src/test/txvalidation_tests.cpp b/src/test/txvalidation_tests.cpp
index 36042431f85c..5941e2a75619 100644
--- a/src/test/txvalidation_tests.cpp
+++ b/src/test/txvalidation_tests.cpp
@@ -8,6 +8,8 @@
 #include <policy/policy.h>
 #include <primitives/transaction.h>
 #include <script/script.h>
+#include <script/sign.h>
+#include <script/signingprovider.h>
 #include <script/standard.h>
 #include <test/util/setup_common.h>
 #include <validation.h>
@@ -20,6 +22,11 @@ struct TestChain100NoDIP0001Setup : public TestChain100Setup {
         : TestChain100Setup{CBaseChainParams::REGTEST, {"-testactivationheight=dip0001@2000"}} {}
 };
 
+struct TestChain100DIP3Setup : public TestChain100Setup {
+    TestChain100DIP3Setup()
+        : TestChain100Setup{CBaseChainParams::REGTEST, {"-dip3params=101:500"}} {}
+};
+
 
 BOOST_AUTO_TEST_SUITE(txvalidation_tests)
 
@@ -55,4 +62,31 @@ BOOST_FIXTURE_TEST_CASE(tx_mempool_reject_coinbase, TestChain100Setup)
     BOOST_CHECK_EQUAL(result.m_state.GetRejectReason(), "coinbase");
     BOOST_CHECK(result.m_state.GetResult() == TxValidationResult::TX_CONSENSUS);
 }
+
+/**
+ * Ensure that a negative nVersion is rejected by the mempool and in a block.
+ */
+BOOST_FIXTURE_TEST_CASE(tx_reject_negative_version, TestChain100DIP3Setup)
+{
+    const CScript scriptPubKey = CScript() << ToByteVector(coinbaseKey.GetPubKey()) << OP_CHECKSIG;
+    CMutableTransaction tx;
+    tx.nVersion = -1;
+    tx.vin.emplace_back(COutPoint{m_coinbase_txns[0]->GetHash(), 0});
+    tx.vout.emplace_back(1 * COIN, scriptPubKey);
+    FillableSigningProvider keystore;
+    keystore.AddKey(coinbaseKey);
+    BOOST_REQUIRE(SignSignature(keystore, *m_coinbase_txns[0], tx, 0, SIGHASH_ALL));
+
+    {
+        LOCK(cs_main);
+        const MempoolAcceptResult result = m_node.chainman->ProcessTransaction(MakeTransactionRef(tx));
+        BOOST_CHECK(result.m_result_type == MempoolAcceptResult::ResultType::INVALID);
+        BOOST_CHECK_EQUAL(result.m_state.GetRejectReason(), "bad-txns-version");
+    }
+
+    const int height{WITH_LOCK(cs_main, return m_node.chainman->ActiveChain().Height())};
+    const auto block = std::make_shared<CBlock>(CreateBlock({tx}, scriptPubKey, m_node.chainman->ActiveChainstate()));
+    BOOST_CHECK(!m_node.chainman->ProcessNewBlock(block, /*force_processing=*/true, /*new_block=*/nullptr));
+    BOOST_CHECK_EQUAL(WITH_LOCK(cs_main, return m_node.chainman->ActiveChain().Height()), height);
+}
 BOOST_AUTO_TEST_SUITE_END()
diff --git a/src/util/fs_helpers.cpp b/src/util/fs_helpers.cpp
index 7cc771d232c5..6394167ccaf8 100644
--- a/src/util/fs_helpers.cpp
+++ b/src/util/fs_helpers.cpp
@@ -198,10 +198,10 @@ void RemoveAllDurably(const fs::path& path)
     SyncDirectoryOrThrow(path.parent_path());
 }
 
-bool TruncateFile(FILE* file, unsigned int length)
+bool TruncateFile(FILE* file, uint64_t length)
 {
 #if defined(WIN32)
-    return _chsize(_fileno(file), length) == 0;
+    return _chsize_s(_fileno(file), length) == 0;
 #else
     return ftruncate(fileno(file), length) == 0;
 #endif
@@ -235,7 +235,7 @@ int RaiseFileDescriptorLimit(int nMinFD)
  * this function tries to make a particular range of a file allocated (corresponding to disk space)
  * it is advisory, and the range specified in the arguments will never contain live data
  */
-void AllocateFileRange(FILE* file, unsigned int offset, unsigned int length)
+void AllocateFileRange(FILE* file, uint64_t offset, unsigned int length)
 {
 #if defined(WIN32)
     // Windows-specific version
@@ -270,7 +270,7 @@ void AllocateFileRange(FILE* file, unsigned int offset, unsigned int length)
     // Fallback version
     // TODO: just write one byte per block
     static const char buf[65536] = {};
-    if (fseek(file, offset, SEEK_SET)) {
+    if (FileSeek64(file, offset, SEEK_SET)) {
         return;
     }
     while (length > 0) {
diff --git a/src/util/fs_helpers.h b/src/util/fs_helpers.h
index f4af1f9e4897..8ac2fa919f66 100644
--- a/src/util/fs_helpers.h
+++ b/src/util/fs_helpers.h
@@ -42,9 +42,40 @@ void RenameDurably(const fs::path& src, const fs::path& dest);
  *  counterpart for deletions, with the same throw contract as RenameDurably(). */
 void RemoveAllDurably(const fs::path& path);
 
-bool TruncateFile(FILE* file, unsigned int length);
+bool TruncateFile(FILE* file, uint64_t length);
+
+/**
+ * 64-bit-clean file positioning.
+ *
+ * The wrapper is necessary for Windows, because `long` is only 32 bits there,
+ * even in 64-bit builds (LLP64).
+ */
+inline int FileSeek64(FILE* file, int64_t offset, int origin)
+{
+#if defined(WIN32)
+    return _fseeki64(file, offset, origin);
+#else
+    return fseeko(file, offset, origin);
+#endif
+}
+
+/**
+ * 64-bit-clean file positioning.
+ *
+ * The wrapper is necessary for Windows, because `long` is only 32 bits there,
+ * even in 64-bit builds (LLP64).
+ */
+inline int64_t FileTell64(FILE* file)
+{
+#if defined(WIN32)
+    return _ftelli64(file);
+#else
+    return ftello(file);
+#endif
+}
+
 int RaiseFileDescriptorLimit(int nMinFD);
-void AllocateFileRange(FILE* file, unsigned int offset, unsigned int length);
+void AllocateFileRange(FILE* file, uint64_t offset, unsigned int length);
 
 /**
  * Rename src to dest.
diff --git a/src/util/sock.cpp b/src/util/sock.cpp
index 5daf694e57b6..ce2687eaa9d3 100644
--- a/src/util/sock.cpp
+++ b/src/util/sock.cpp
@@ -367,12 +367,14 @@ bool Sock::WaitManySelect(std::chrono::milliseconds timeout,
         const auto& s = sock;
         if (events.requested & RECV) {
             FD_SET(s, &recv);
+            FD_SET(s, &err);
         }
         if (events.requested & SEND) {
             FD_SET(s, &send);
         }
-        FD_SET(s, &err);
-        socket_max = std::max(socket_max, s);
+        if (events.requested & (RECV | SEND)) {
+            socket_max = std::max(socket_max, s);
+        }
     }
 
     timeval tv = MillisToTimeval(timeout);
diff --git a/src/validation.cpp b/src/validation.cpp
index 85d41ae6d7c6..8150ab666817 100644
--- a/src/validation.cpp
+++ b/src/validation.cpp
@@ -376,6 +376,11 @@ static bool ContextualCheckTransaction(const CTransaction& tx, TxValidationState
         } else if (tx.nType != TRANSACTION_NORMAL) {
             return state.Invalid(TxValidationResult::TX_CONSENSUS, "bad-txns-type");
         }
+        // Releases that sign-extended nVersion over nType re-serialized a negative nVersion with nType 0xffff,
+        // so a block carrying one was accepted only by the peers that received the miner's own bytes
+        if (tx.nVersion < 0) {
+            return state.Invalid(TxValidationResult::TX_CONSENSUS, "bad-txns-version");
+        }
     }
 
     // Size limits
diff --git a/test/functional/feature_llmq_dkgerrors.py b/test/functional/feature_llmq_dkgerrors.py
index 1041c7c3d726..a150a4dfc5b7 100755
--- a/test/functional/feature_llmq_dkgerrors.py
+++ b/test/functional/feature_llmq_dkgerrors.py
@@ -50,6 +50,19 @@ def run_test(self):
         qh = self.mine_quorum(expected_contributions=3, expected_complaints=2, expected_justifications=1, mninfos_valid=mninfos_valid)
         self.assert_member_valid(qh, self.mninfo[0].proTxHash, True)
 
+        self.log.info("Lets deliver a structurally-invalid (all-zero) contribution share but provide a correct justification")
+        # Regression test for the DKG abort via an invalid decrypted contribution share:
+        # before the intake gate rejected it, the share reached CBLSSecretKey::AggregateInsecure()
+        # in the batched verification and its assert aborted every honest recipient (SIGABRT).
+        # With the gate the invalid share is treated like a bad contribution: recipients complain,
+        # the sender justifies with its real shares, and the member remains valid - no crash.
+        # contribution-lie stays enabled from the previous case; contribution-invalid overrides it
+        # with an all-zero (structurally invalid) share, which is the EMBARGO-8 trigger.
+        self.mninfo[0].get_node(self).quorum('dkgsimerror', 'contribution-invalid', 100)
+        qh = self.mine_quorum(expected_contributions=3, expected_complaints=2, expected_justifications=1, mninfos_valid=mninfos_valid)
+        self.assert_member_valid(qh, self.mninfo[0].proTxHash, True)
+        self.mninfo[0].get_node(self).quorum('dkgsimerror', 'contribution-invalid', 0)
+
         self.log.info("Lets lie in the contribution and then omit the justification")
         self.mninfo[0].get_node(self).quorum('dkgsimerror', 'justify-omit', 100)
         qh = self.mine_quorum(expected_contributions=3, expected_complaints=2, mninfos_valid=mninfos_valid)
diff --git a/test/functional/p2p_platform_ban.py b/test/functional/p2p_platform_ban.py
index bec6960051ec..405d6e7866f6 100755
--- a/test/functional/p2p_platform_ban.py
+++ b/test/functional/p2p_platform_ban.py
@@ -73,6 +73,11 @@ def run_test(self):
         wait_until_helper(lambda: p2p_node2.message_count["platformban"] > 0, timeout=10, lock=p2p_lock)
         p2p_node2.message_count["platformban"] = 0
 
+        self.log.info("An already verified Platform ban skips handler work")
+        ban_inv_hash = hash256(msg.serialize()[:-96])[::-1].hex()
+        with self.mninfo[2].get_node(self).assert_debug_log([], unexpected_msgs=[f"PLATFORMBAN -- hash: {ban_inv_hash}"]):
+            p2p_node2.send_and_ping(msg)
+
         assert not self.check_banned(self.mninfo[0])
 
         mninfos_valid = self.mninfo.copy()[1:]