diff --git a/src/blockencodings.cpp b/src/blockencodings.cpp
index f12b45b49354..9c5fbc71d32a 100644
--- a/src/blockencodings.cpp
+++ b/src/blockencodings.cpp
@@ -26,7 +26,11 @@ CBlockHeaderAndShortTxIDs::CBlockHeaderAndShortTxIDs(const CBlock& block) :
     prefilledtxn[0] = {0, block.vtx[0]};
     for (size_t i = 1; i < block.vtx.size(); i++) {
         const CTransaction& tx = *block.vtx[i];
-        shorttxids[i - 1] = GetShortID(tx.GetHash());
+        // Short IDs are computed from instance hashes so that a mempool entry holding a different
+        // re-signed instance of a version 2 asset unlock (same txid, different quorum signing
+        // info) is treated as missing and requested, instead of being spliced into the block and
+        // failing the coinbase asset unlock commitment.
+        shorttxids[i - 1] = GetShortID(tx.GetInstanceHash());
     }
 }
 
diff --git a/src/core_write.cpp b/src/core_write.cpp
index e94b0af4add7..fe45f3eca039 100644
--- a/src/core_write.cpp
+++ b/src/core_write.cpp
@@ -324,6 +324,9 @@ void TxToUniv(const CTransaction& tx, const uint256& block_hash, UniValue& entry
         if (const auto opt_assetUnlockTx = GetTxPayload<CAssetUnlockPayload>(tx)) {
             entry.pushKV("assetUnlockTx", opt_assetUnlockTx->ToJson());
         }
+        if (IsAssetUnlockWithStableTxid(tx)) {
+            entry.pushKV("instanceHash", tx.GetInstanceHash().ToString());
+        }
     }
 
     if (have_undo) {
diff --git a/src/evo/assetlocktx.cpp b/src/evo/assetlocktx.cpp
index 9388e1c29b15..d8d9a27fbaaa 100644
--- a/src/evo/assetlocktx.cpp
+++ b/src/evo/assetlocktx.cpp
@@ -175,7 +175,8 @@ bool CAssetUnlockPayload::VerifySig(const llmq::CQuorumManager& qman, const CCha
 template <typename VerifySig>
 static bool CheckAssetUnlockTxImpl(const BlockManager& blockman, VerifySig&& verify_sig, const CTransaction& tx,
                                    gsl::not_null<const CBlockIndex*> pindexPrev,
-                                   const std::optional<CRangesSet>& indexes, TxValidationState& state)
+                                   const std::optional<CRangesSet>& indexes, bool is_v24_active,
+                                   TxValidationState& state)
 {
     // Some checks depends from blockchain status also, such as `known indexes` and `withdrawal limits`
     // They are omitted here and done by CCreditPool
@@ -200,6 +201,9 @@ static bool CheckAssetUnlockTxImpl(const BlockManager& blockman, VerifySig&& ver
     if (assetUnlockTx.getVersion() == 0 || assetUnlockTx.getVersion() > CAssetUnlockPayload::CURRENT_VERSION) {
         return state.Invalid(TxValidationResult::TX_BAD_SPECIAL, "bad-assetunlocktx-version");
     }
+    if (!is_v24_active && assetUnlockTx.getVersion() > CAssetUnlockPayload::INITIAL_VERSION) {
+        return state.Invalid(TxValidationResult::TX_BAD_SPECIAL, "bad-assetunlocktx-version-2");
+    }
 
     if (indexes != std::nullopt && indexes->Contains(assetUnlockTx.getIndex())) {
         return state.Invalid(TxValidationResult::TX_CONSENSUS, "bad-assetunlock-duplicated-index");
@@ -214,30 +218,32 @@ static bool CheckAssetUnlockTxImpl(const BlockManager& blockman, VerifySig&& ver
     const CAssetUnlockPayload payload_copy{assetUnlockTx.getVersion(), assetUnlockTx.getIndex(), assetUnlockTx.getFee(), assetUnlockTx.getRequestedHeight(), assetUnlockTx.getQuorumHash(), CBLSSignature{}};
     SetTxPayload(tx_copy, payload_copy);
 
-    uint256 msgHash = tx_copy.GetHash();
+    // The signed message must commit to requestedHeight and quorumHash even though the version 2
+    // txid excludes them, so hash the full serialization rather than using GetHash().
+    uint256 msgHash = ::SerializeHash(tx_copy);
 
     return verify_sig(assetUnlockTx, msgHash, pindexPrev, state);
 }
 
 bool CheckAssetUnlockTx(const BlockManager& blockman, const llmq::CQuorumManager& qman, const CTransaction& tx,
                         gsl::not_null<const CBlockIndex*> pindexPrev, const std::optional<CRangesSet>& indexes,
-                        TxValidationState& state)
+                        bool is_v24_active, TxValidationState& state)
 {
     return CheckAssetUnlockTxImpl(blockman, [&](const CAssetUnlockPayload& payload, const uint256& msg_hash,
                                                 const CBlockIndex* pindex, TxValidationState& tx_state) {
         return payload.VerifySig(qman, msg_hash, pindex, tx_state);
-    }, tx, pindexPrev, indexes, state);
+    }, tx, pindexPrev, indexes, is_v24_active, state);
 }
 
 bool CheckAssetUnlockTx(const BlockManager& blockman, const llmq::CQuorumManager& qman, const CChain& chain,
                         const CTransaction& tx, gsl::not_null<const CBlockIndex*> pindexPrev,
-                        const std::optional<CRangesSet>& indexes, TxValidationState& state)
+                        const std::optional<CRangesSet>& indexes, bool is_v24_active, TxValidationState& state)
 {
     AssertLockHeld(::cs_main);
     return CheckAssetUnlockTxImpl(blockman, [&](const CAssetUnlockPayload& payload, const uint256& msg_hash,
                                                 const CBlockIndex* pindex, TxValidationState& tx_state) NO_THREAD_SAFETY_ANALYSIS {
         return payload.VerifySig(qman, chain, msg_hash, pindex, tx_state);
-    }, tx, pindexPrev, indexes, state);
+    }, tx, pindexPrev, indexes, is_v24_active, state);
 }
 
 bool GetAssetUnlockFee(const CTransaction& tx, CAmount& txfee, TxValidationState& state)
diff --git a/src/evo/assetlocktx.h b/src/evo/assetlocktx.h
index 3dea2c5e13a8..ae1165f402b0 100644
--- a/src/evo/assetlocktx.h
+++ b/src/evo/assetlocktx.h
@@ -75,8 +75,13 @@ class CAssetLockPayload
 class CAssetUnlockPayload
 {
 public:
-    static constexpr uint8_t CURRENT_VERSION = 1;
+    static constexpr uint8_t INITIAL_VERSION = 1;
+    /** Serialized identically to version 1, but the transaction hash excludes the quorum signing
+     *  info (requestedHeight, quorumHash, quorumSig) so every re-signed instance of one withdrawal
+     *  shares one txid; see IsAssetUnlockWithStableTxid(). Gated on DEPLOYMENT_V24. */
+    static constexpr uint8_t CURRENT_VERSION = 2;
     static constexpr auto SPECIALTX_TYPE = TRANSACTION_ASSET_UNLOCK;
+    static_assert(CURRENT_VERSION >= ASSET_UNLOCK_STABLE_TXID_VERSION);
 
     static constexpr size_t MAXIMUM_WITHDRAWALS = 32;
 
@@ -163,10 +168,10 @@ class CAssetUnlockPayload
 };
 
 bool CheckAssetLockTx(const CTransaction& tx, TxValidationState& state, bool is_v24_active);
-bool CheckAssetUnlockTx(const node::BlockManager& blockman, const llmq::CQuorumManager& qman, const CTransaction& tx, gsl::not_null<const CBlockIndex*> pindexPrev, const std::optional<CRangesSet>& indexes, TxValidationState& state);
+bool CheckAssetUnlockTx(const node::BlockManager& blockman, const llmq::CQuorumManager& qman, const CTransaction& tx, gsl::not_null<const CBlockIndex*> pindexPrev, const std::optional<CRangesSet>& indexes, bool is_v24_active, TxValidationState& state);
 bool CheckAssetUnlockTx(const node::BlockManager& blockman, const llmq::CQuorumManager& qman, const CChain& chain,
                         const CTransaction& tx, gsl::not_null<const CBlockIndex*> pindexPrev,
-                        const std::optional<CRangesSet>& indexes, TxValidationState& state)
+                        const std::optional<CRangesSet>& indexes, bool is_v24_active, TxValidationState& state)
     EXCLUSIVE_LOCKS_REQUIRED(::cs_main);
 bool GetAssetUnlockFee(const CTransaction& tx, CAmount& txfee, TxValidationState& state);
 
diff --git a/src/evo/cbtx.cpp b/src/evo/cbtx.cpp
index 856d8d74ee6c..ad9f6f2e8fef 100644
--- a/src/evo/cbtx.cpp
+++ b/src/evo/cbtx.cpp
@@ -21,7 +21,7 @@
 
 using node::ReadBlockFromDisk;
 
-bool CheckCbTx(const CCbTx& cbTx, const CBlockIndex* pindexPrev, TxValidationState& state)
+bool CheckCbTx(const CCbTx& cbTx, const CBlockIndex* pindexPrev, bool is_v24_active, TxValidationState& state)
 {
     if (cbTx.nVersion == CCbTx::Version::INVALID || cbTx.nVersion >= CCbTx::Version::UNKNOWN) {
         return state.Invalid(TxValidationResult::TX_CONSENSUS, "bad-cbtx-version");
@@ -41,6 +41,11 @@ bool CheckCbTx(const CCbTx& cbTx, const CBlockIndex* pindexPrev, TxValidationSta
         if ((isV20 && cbTx.nVersion < CCbTx::Version::CLSIG_AND_BALANCE) || (!isV20 && cbTx.nVersion >= CCbTx::Version::CLSIG_AND_BALANCE)) {
             return state.Invalid(TxValidationResult::TX_CONSENSUS, "bad-cbtx-version");
         }
+
+        if ((is_v24_active && cbTx.nVersion < CCbTx::Version::MERKLE_ROOT_ASSETUNLOCKS) ||
+            (!is_v24_active && cbTx.nVersion >= CCbTx::Version::MERKLE_ROOT_ASSETUNLOCKS)) {
+            return state.Invalid(TxValidationResult::TX_CONSENSUS, "bad-cbtx-version");
+        }
     }
 
     return true;
@@ -147,11 +152,27 @@ bool CalcCbTxMerkleRootQuorums(const CBlock& block, const CBlockIndex* pindexPre
     return true;
 }
 
+uint256 CalcCbTxMerkleRootAssetUnlocks(const CBlock& block)
+{
+    // Instance hashes cover the quorum signing info that the txids of these transactions - and
+    // therefore the block's merkle root - exclude. Two instances of one withdrawal share a txid,
+    // so duplicate leaves imply a duplicate transaction, which the block merkle-root check
+    // (CheckMerkleRoot, run before this) already rejects; no mutated check is needed here.
+    std::vector<uint256> instance_hashes;
+    for (const auto& tx : block.vtx) {
+        // The miner calls this while the coinbase slot is still an empty placeholder
+        if (tx && IsAssetUnlockWithStableTxid(*tx)) {
+            instance_hashes.push_back(tx->GetInstanceHash());
+        }
+    }
+    return ComputeMerkleRoot(std::move(instance_hashes));
+}
+
 std::string CCbTx::ToString() const
 {
-    return strprintf("CCbTx(nVersion=%d, nHeight=%d, merkleRootMNList=%s, merkleRootQuorums=%s, bestCLHeightDiff=%d, bestCLSig=%s, creditPoolBalance=%d.%08d)",
+    return strprintf("CCbTx(nVersion=%d, nHeight=%d, merkleRootMNList=%s, merkleRootQuorums=%s, bestCLHeightDiff=%d, bestCLSig=%s, creditPoolBalance=%d.%08d, merkleRootAssetUnlocks=%s)",
         static_cast<uint16_t>(nVersion), nHeight, merkleRootMNList.ToString(), merkleRootQuorums.ToString(), bestCLHeightDiff, bestCLSignature.ToString(),
-        creditPoolBalance / COIN, creditPoolBalance % COIN);
+        creditPoolBalance / COIN, creditPoolBalance % COIN, merkleRootAssetUnlocks.ToString());
 }
 
 std::optional<std::pair<CBLSSignature, uint32_t>> GetNonNullCoinbaseChainlock(const CBlockIndex* pindex)
diff --git a/src/evo/cbtx.h b/src/evo/cbtx.h
index da6d92f802a8..bb552a78c653 100644
--- a/src/evo/cbtx.h
+++ b/src/evo/cbtx.h
@@ -34,6 +34,7 @@ class CCbTx
         MERKLE_ROOT_MNLIST = 1,
         MERKLE_ROOT_QUORUMS = 2,
         CLSIG_AND_BALANCE = 3,
+        MERKLE_ROOT_ASSETUNLOCKS = 4,
         UNKNOWN,
     };
 
@@ -45,6 +46,10 @@ class CCbTx
     uint32_t bestCLHeightDiff{0};
     CBLSSignature bestCLSignature;
     CAmount creditPoolBalance{0};
+    /** Merkle root over the instance hashes of the block's version 2+ asset unlock transactions
+     *  (block order; null when there are none). Their txids exclude the quorum signing info, so
+     *  the block's merkle root does not commit to it; this root restores that commitment. */
+    uint256 merkleRootAssetUnlocks;
 
     SERIALIZE_METHODS(CCbTx, obj)
     {
@@ -56,6 +61,9 @@ class CCbTx
                 READWRITE(COMPACTSIZE(obj.bestCLHeightDiff));
                 READWRITE(obj.bestCLSignature);
                 READWRITE(obj.creditPoolBalance);
+                if (obj.nVersion >= Version::MERKLE_ROOT_ASSETUNLOCKS) {
+                    READWRITE(obj.merkleRootAssetUnlocks);
+                }
             }
         }
 
@@ -68,11 +76,12 @@ class CCbTx
 };
 template<> struct is_serializable_enum<CCbTx::Version> : std::true_type {};
 
-bool CheckCbTx(const CCbTx& cbTx, const CBlockIndex* pindexPrev, TxValidationState& state);
+bool CheckCbTx(const CCbTx& cbTx, const CBlockIndex* pindexPrev, bool is_v24_active, TxValidationState& state);
 
 bool CalcCbTxMerkleRootQuorums(const CBlock& block, const CBlockIndex* pindexPrev,
                                const llmq::CQuorumBlockProcessor& quorum_block_processor, uint256& merkleRootRet,
                                BlockValidationState& state);
+uint256 CalcCbTxMerkleRootAssetUnlocks(const CBlock& block);
 
 std::optional<std::pair<CBLSSignature, uint32_t>> GetNonNullCoinbaseChainlock(const CBlockIndex* pindex);
 
diff --git a/src/evo/core_write.cpp b/src/evo/core_write.cpp
index 4ebe78675f2d..3d97569ad215 100644
--- a/src/evo/core_write.cpp
+++ b/src/evo/core_write.cpp
@@ -143,6 +143,9 @@ UniValue CCbTx::ToJson() const
             ret.pushKV("bestCLHeightDiff", bestCLHeightDiff);
             ret.pushKV("bestCLSignature", bestCLSignature.ToString());
             ret.pushKV("creditPoolBalance", ValueFromAmount(creditPoolBalance));
+            if (nVersion >= CCbTx::Version::MERKLE_ROOT_ASSETUNLOCKS) {
+                ret.pushKV("merkleRootAssetUnlocks", merkleRootAssetUnlocks.ToString());
+            }
         }
     }
     return ret;
diff --git a/src/evo/creditpool.cpp b/src/evo/creditpool.cpp
index 239b951a27d0..668e01a3d8f9 100644
--- a/src/evo/creditpool.cpp
+++ b/src/evo/creditpool.cpp
@@ -137,7 +137,11 @@ std::optional<CCreditPool> CCreditPoolManager::GetFromCache(const CBlockIndex& b
 
 void CCreditPoolManager::AddToCache(const uint256& block_hash, int height, const CCreditPool &pool)
 {
-    if (height % DISK_SNAPSHOT_PERIOD == 0) {
+    // The disk snapshot is an optimization; skip it outside a block-scoped EvoDB transaction
+    // (e.g. a pool constructed on a cold cache during mempool acceptance or template creation),
+    // where the write would never be committed and would trip the clean-transaction assertion
+    // at the next root commit. A skipped snapshot is reconstructed from an earlier one.
+    if (height % DISK_SNAPSHOT_PERIOD == 0 && evoDb.HasActiveTransaction()) {
         if (!evoDb.WriteDerived(std::make_pair(DB_CREDITPOOL_SNAPSHOT, block_hash), pool)) {
             // A mismatch is local EvoDB corruption, not a statement about the
             // block. Abort here: some callers (miner, RPC) never pass through a
diff --git a/src/evo/evodb.h b/src/evo/evodb.h
index 40d37b48229d..11b47ed0ec6a 100644
--- a/src/evo/evodb.h
+++ b/src/evo/evodb.h
@@ -115,6 +115,16 @@ class CEvoDB
 
     std::unique_ptr<CEvoDBScopedCommitter> BeginTransaction(EvoDbIdentity identity = EvoDbIdentity::NORMAL) EXCLUSIVE_LOCKS_REQUIRED(!cs);
 
+    /** Whether a block-scoped transaction is open. Writes performed outside one are never
+     *  committed and trip the clean-transaction assertion at the next root commit, so callers
+     *  reachable from transaction-less contexts (mempool acceptance, mining, RPC) must skip
+     *  optional persistence when this is false. */
+    bool HasActiveTransaction() const EXCLUSIVE_LOCKS_REQUIRED(!cs)
+    {
+        LOCK(cs);
+        return active_transaction.has_value();
+    }
+
     CurTransaction& GetCurTransaction() EXCLUSIVE_LOCKS_REQUIRED(cs)
     {
         AssertLockHeld(cs); // lock must be held from outside as long as the DB transaction is used
diff --git a/src/evo/specialtxman.cpp b/src/evo/specialtxman.cpp
index d8b89b43a89b..26c122ee44d1 100644
--- a/src/evo/specialtxman.cpp
+++ b/src/evo/specialtxman.cpp
@@ -229,7 +229,7 @@ static bool CheckSpecialTxInner(CDeterministicMNManager& dmnman, llmq::CQuorumSn
                 return state.Invalid(TxValidationResult::TX_CONSENSUS, "bad-cbtx-invalid");
             }
             if (const auto opt_cbTx = GetTxPayload<CCbTx>(tx)) {
-                return CheckCbTx(*opt_cbTx, pindexPrev, state);
+                return CheckCbTx(*opt_cbTx, pindexPrev, DeploymentActiveAfter(pindexPrev, chainman, Consensus::DEPLOYMENT_V24), state);
             } else {
                 return state.Invalid(TxValidationResult::TX_CONSENSUS, "bad-cbtx-payload");
             }
@@ -241,9 +241,11 @@ static bool CheckSpecialTxInner(CDeterministicMNManager& dmnman, llmq::CQuorumSn
                            CheckMNHFTx(chainman, qman, tx, pindexPrev, state);
         case TRANSACTION_ASSET_LOCK:
             return CheckAssetLockTx(tx, state, DeploymentActiveAfter(pindexPrev, chainman, Consensus::DEPLOYMENT_V24));
-        case TRANSACTION_ASSET_UNLOCK:
-            return chain ? CheckAssetUnlockTx(chainman.m_blockman, qman, *chain, tx, pindexPrev, indexes, state) :
-                           CheckAssetUnlockTx(chainman.m_blockman, qman, tx, pindexPrev, indexes, state);
+        case TRANSACTION_ASSET_UNLOCK: {
+            const bool is_v24_active{DeploymentActiveAfter(pindexPrev, chainman, Consensus::DEPLOYMENT_V24)};
+            return chain ? CheckAssetUnlockTx(chainman.m_blockman, qman, *chain, tx, pindexPrev, indexes, is_v24_active, state) :
+                           CheckAssetUnlockTx(chainman.m_blockman, qman, tx, pindexPrev, indexes, is_v24_active, state);
+        }
         }
     } catch (const std::exception& e) {
         LogPrintf("%s -- failed: %s\n", __func__, e.what());
@@ -714,7 +716,8 @@ bool CSpecialTxProcessor::ProcessSpecialTxsInBlock(Chainstate& chainstate, const
             }
             if (opt_cbTx = GetTxPayload<CCbTx>(*tx); opt_cbTx) {
                 TxValidationState tx_state;
-                if (!CheckCbTx(*opt_cbTx, pindex->pprev, tx_state)) {
+                if (!CheckCbTx(*opt_cbTx, pindex->pprev,
+                               DeploymentActiveAfter(pindex->pprev, m_chainman, Consensus::DEPLOYMENT_V24), tx_state)) {
                     assert(tx_state.GetResult() == TxValidationResult::TX_CONSENSUS ||
                            tx_state.GetResult() == TxValidationResult::TX_BAD_SPECIAL);
                     return state.Invalid(BlockValidationResult::BLOCK_CONSENSUS, tx_state.GetRejectReason(),
diff --git a/src/instantsend/signing.cpp b/src/instantsend/signing.cpp
index 73a42cd099c3..d14e7646a408 100644
--- a/src/instantsend/signing.cpp
+++ b/src/instantsend/signing.cpp
@@ -189,6 +189,12 @@ bool InstantSendSigner::CheckCanLock(const COutPoint& outpoint, bool printDebug,
 
     auto mempoolTx = m_mempool.get(outpoint.hash);
     if (mempoolTx) {
+        if (IsAssetUnlockWithStableTxid(*mempoolTx)) {
+            // An unmined version 2 asset unlock was quorum-signed, so the withdrawal is
+            // irreversible on Platform and will be re-signed until mined under this same txid.
+            // Spends of its outputs may therefore be locked before it is mined.
+            return outpoint.n < mempoolTx->vout.size();
+        }
         if (printDebug) {
             LogPrint(BCLog::INSTANTSEND, "%s -- txid=%s: parent mempool TX %s is not locked\n", __func__,
                      txHash.ToString(), outpoint.hash.ToString());
diff --git a/src/llmq/signing.cpp b/src/llmq/signing.cpp
index 21824b2f687b..e8e33588762b 100644
--- a/src/llmq/signing.cpp
+++ b/src/llmq/signing.cpp
@@ -542,16 +542,27 @@ bool CSigningManager::ProcessRecoveredSig(const std::shared_ptr<const CRecovered
         if (db.GetRecoveredSigById(llmqType, recoveredSig->getId(), otherRecoveredSig)) {
             auto otherSignHash = otherRecoveredSig.buildSignHash();
             if (signHash.Get() != otherSignHash.Get()) {
-                // this should really not happen, as each masternode is participating in only one vote,
-                // even if it's a member of multiple quorums. so a majority is only possible on one quorum and one msgHash per id
-                LogPrintf("CSigningManager::%s -- conflicting recoveredSig for signHash=%s, id=%s, msgHash=%s, otherSignHash=%s\n", __func__,
-                          signHash.ToString(), recoveredSig->getId().ToString(), recoveredSig->getMsgHash().ToString(), otherSignHash.ToString());
+                if (llmqType == Params().GetConsensus().llmqTypePlatform) {
+                    // Platform re-signs expired withdrawals under the same request id with a new
+                    // message hash; the latest recovered sig supersedes the previous one. The
+                    // truncate and the write below are separate batches; a crash in between only
+                    // loses a sig that Platform will produce again on the next re-sign.
+                    LogPrint(BCLog::LLMQ, "CSigningManager::%s -- replacing recoveredSig for platform signHash=%s, id=%s, msgHash=%s, otherSignHash=%s\n", __func__,
+                             signHash.ToString(), recoveredSig->getId().ToString(), recoveredSig->getMsgHash().ToString(), otherSignHash.ToString());
+                    db.TruncateRecoveredSig(llmqType, recoveredSig->getId());
+                } else {
+                    // this should really not happen, as each masternode is participating in only one vote,
+                    // even if it's a member of multiple quorums. so a majority is only possible on one quorum and one msgHash per id
+                    LogPrintf("CSigningManager::%s -- conflicting recoveredSig for signHash=%s, id=%s, msgHash=%s, otherSignHash=%s\n", __func__,
+                              signHash.ToString(), recoveredSig->getId().ToString(), recoveredSig->getMsgHash().ToString(), otherSignHash.ToString());
+                    return false;
+                }
             } else {
                 // Looks like we're trying to process a recSig that is already known. This might happen if the same
                 // recSig comes in through regular QRECSIG messages and at the same time through some other message
                 // which allowed to reconstruct a recSig (e.g. ISLOCK). In this case, just bail out.
+                return false;
             }
-            return false;
         } else {
             // This case is very unlikely. It can only happen when cleanup caused this specific recSig to vanish
             // between the HasRecoveredSigForId and GetRecoveredSigById call. If that happens, treat it as if we
diff --git a/src/llmq/signing_shares.cpp b/src/llmq/signing_shares.cpp
index 87b9864edbb9..ae693ec8c7c4 100644
--- a/src/llmq/signing_shares.cpp
+++ b/src/llmq/signing_shares.cpp
@@ -812,6 +812,9 @@ bool CSigSharesManager::AsyncSignIfMember(Consensus::LLMQType llmqType, const ui
                     LogPrintf("%s -- already voted for id=%s and msgHash=%s. Signing for different " /* Continued */
                               "msgHash=%s\n",
                               __func__, id.ToString(), prevMsgHash.ToString(), msgHash.ToString());
+                    // Drop any recovered sig for the previous message so the new signing session
+                    // is not short-circuited by the by-id lookups in the share pipeline
+                    sigman.TruncateRecoveredSig(llmqType, id);
                     hasVoted = false;
                 } else {
                     LogPrintf("%s -- already voted for id=%s and msgHash=%s. Not voting on " /* Continued */
diff --git a/src/net_processing.cpp b/src/net_processing.cpp
index e25a9a1230c5..f838b0ddc152 100644
--- a/src/net_processing.cpp
+++ b/src/net_processing.cpp
@@ -669,10 +669,14 @@ class PeerManagerImpl final : public PeerManager
     void AddObjectAnnouncement(const CNode& node, const CInv& inv, std::chrono::microseconds current_time)
         EXCLUSIVE_LOCKS_REQUIRED(::cs_main);
 
-    /** Delete all announcements of a transaction across all peers, under both inv types it may
+    /** Delete all announcements of a transaction across all peers, under the inv types it may
      *  have been announced with (MSG_TX and MSG_DSTX). */
     void ForgetTx(const uint256& txid) EXCLUSIVE_LOCKS_REQUIRED(::cs_main);
 
+    /** As above, additionally forgetting the MSG_ASSET_UNLOCK announcement (by instance hash)
+     *  used for version 2 asset unlocks. */
+    void ForgetTx(const CTransaction& tx) EXCLUSIVE_LOCKS_REQUIRED(::cs_main);
+
     /** Helper to process result of external handlers of message */
     void PostProcessMessage(MessageProcessingResult&& ret, NodeId node) override EXCLUSIVE_LOCKS_REQUIRED(!m_peer_mutex);
 
@@ -1638,6 +1642,14 @@ void PeerManagerImpl::ForgetTx(const uint256& txid)
     m_object_request.ForgetTxHash(CInv(MSG_DSTX, txid));
 }
 
+void PeerManagerImpl::ForgetTx(const CTransaction& tx)
+{
+    ForgetTx(tx.GetHash());
+    if (IsAssetUnlockWithStableTxid(tx)) {
+        m_object_request.ForgetTxHash(CInv(MSG_ASSET_UNLOCK, tx.GetInstanceHash()));
+    }
+}
+
 size_t PeerManagerImpl::GetRequestedObjectCount(NodeId nodeid) const
 {
     AssertLockHeld(cs_main);
@@ -1871,7 +1883,7 @@ void PeerManagerImpl::AddToCompactExtraTransactions(const CTransactionRef& tx)
         return;
     if (!vExtraTxnForCompact.size())
         vExtraTxnForCompact.resize(max_extra_txn);
-    vExtraTxnForCompact[vExtraTxnForCompactIt] = std::make_pair(tx->GetHash(), tx);
+    vExtraTxnForCompact[vExtraTxnForCompactIt] = std::make_pair(tx->GetInstanceHash(), tx);
     vExtraTxnForCompactIt = (vExtraTxnForCompactIt + 1) % max_extra_txn;
 }
 
@@ -2122,7 +2134,7 @@ void PeerManagerImpl::BlockConnected(const std::shared_ptr<const CBlock>& pblock
         }
         for (const auto& ptx : pblock->vtx) {
             // Confirmed transactions no longer need to be requested.
-            ForgetTx(ptx->GetHash());
+            ForgetTx(*ptx);
         }
     }
 
@@ -2132,6 +2144,11 @@ void PeerManagerImpl::BlockConnected(const std::shared_ptr<const CBlock>& pblock
         LOCK(m_recent_confirmed_transactions_mutex);
         for (const auto& ptx : pblock->vtx) {
             m_recent_confirmed_transactions.insert(ptx->GetHash());
+            // Version 2 asset unlocks are announced and deduplicated by instance hash; record the
+            // mined instance so AlreadyHave() stops re-requesting it once it leaves the mempool.
+            if (IsAssetUnlockWithStableTxid(*ptx)) {
+                m_recent_confirmed_transactions.insert(ptx->GetInstanceHash());
+            }
         }
     }
 
@@ -2293,6 +2310,7 @@ bool PeerManagerImpl::AlreadyHave(const CInv& inv)
     {
     case MSG_TX:
     case MSG_DSTX:
+    case MSG_ASSET_UNLOCK:
         {
             if (m_chainman.ActiveChain().Tip()->GetBlockHash() != hashRecentRejectsChainTip)
             {
@@ -2304,6 +2322,19 @@ bool PeerManagerImpl::AlreadyHave(const CInv& inv)
                 m_recent_rejects.reset();
             }
 
+            if (inv.IsMsgAssetUnlock()) {
+                // inv.hash is the instance hash of a version 2 asset unlock. Rejects and mined
+                // instances are tracked by instance hash, so a rejected or already-mined stale
+                // instance never blocks a fresher re-signed instance of the same withdrawal
+                // (which shares its txid) yet is not endlessly re-requested either.
+                if (WITH_LOCK(m_recent_confirmed_transactions_mutex,
+                              return m_recent_confirmed_transactions.contains(inv.hash))) {
+                    return true;
+                }
+                return m_recent_rejects.contains(inv.hash) ||
+                       m_mempool.GetAssetUnlockByInstanceHash(inv.hash) != nullptr;
+            }
+
             if (m_orphanage.HaveTx(inv.hash)) return true;
 
             {
@@ -2825,6 +2856,12 @@ void PeerManagerImpl::ProcessGetBlockData(CNode& pfrom, Peer& peer, const CInv&
 CTransactionRef PeerManagerImpl::FindTxForGetData(const CNode* peer, const uint256& txid, const std::chrono::seconds mempool_req, const std::chrono::seconds now)
 {
     auto txinfo = m_mempool.info(txid);
+    if (!txinfo.tx) {
+        // A MSG_ASSET_UNLOCK getdata identifies a version 2 asset unlock by its instance hash
+        if (const auto unlock_tx = m_mempool.GetAssetUnlockByInstanceHash(txid)) {
+            txinfo = m_mempool.info(unlock_tx->GetHash());
+        }
+    }
     if (txinfo.tx) {
         // If a TX could have been INVed in reply to a MEMPOOL request,
         // or is older than UNCONDITIONAL_RELAY_DELAY, permit the request
@@ -3536,6 +3573,18 @@ static bool CanAnnounceDstxTo(const CCoinJoinBroadcastTx& dstx, int peer_version
            peer_version >= COINJOIN_REBALANCE_VERSION;
 }
 
+//! The inventory type and hash to announce a mempool transaction with to a peer at the given
+//! negotiated protocol version. Version 2 asset unlocks are announced by instance hash (MSG_ASSET_UNLOCK)
+//! so a re-signed instance of a withdrawal the peer already has (sharing its txid) is still announced;
+//! a getdata for it is served as a plain `tx`. Older peers get MSG_TX and never learn of refreshes.
+static std::pair<int, uint256> GetTxAnnouncement(const CTransaction& tx, int peer_version)
+{
+    if (IsAssetUnlockWithStableTxid(tx) && peer_version >= ASSET_UNLOCK_INV_VERSION) {
+        return {MSG_ASSET_UNLOCK, tx.GetInstanceHash()};
+    }
+    return {MSG_TX, tx.GetHash()};
+}
+
 // do_return signals the caller to stop further processing of the DSTX.
 struct DSTXValidationResult {
     DSTXValidationScore score;
@@ -4772,9 +4821,15 @@ void PeerManagerImpl::ProcessMessage(
         const CTransaction& tx = *ptx;
 
         const uint256& txid = ptx->GetHash();
-        AddKnownInv(*peer, txid);
-
-        CInv inv(nInvType, tx.GetHash());
+        // Version 2 asset unlocks are announced, requested and deduplicated by instance hash so
+        // that a re-signed instance of a withdrawal already in the mempool (sharing its txid)
+        // still propagates.
+        const bool is_stable_unlock{IsAssetUnlockWithStableTxid(tx)};
+        if (is_stable_unlock) nInvType = MSG_ASSET_UNLOCK;
+        const uint256& relay_hash{is_stable_unlock ? tx.GetInstanceHash() : txid};
+        AddKnownInv(*peer, relay_hash);
+
+        CInv inv(nInvType, relay_hash);
         {
             LOCK(cs_main);
             // A MSG_TX request may be answered with a DSTX message and vice versa (a getdata for
@@ -4782,6 +4837,9 @@ void PeerManagerImpl::ProcessMessage(
             // type the request was tracked under.
             m_object_request.ReceivedResponse(pfrom.GetId(), CInv(MSG_TX, txid));
             m_object_request.ReceivedResponse(pfrom.GetId(), CInv(MSG_DSTX, txid));
+            if (is_stable_unlock) {
+                m_object_request.ReceivedResponse(pfrom.GetId(), CInv(MSG_ASSET_UNLOCK, relay_hash));
+            }
         }
 
         // Process custom logic, no matter if tx will be accepted to mempool later or not
@@ -4825,7 +4883,7 @@ void PeerManagerImpl::ProcessMessage(
                 m_dstxman.AddDSTX(dstx);
             }
 
-            ForgetTx(tx.GetHash());
+            ForgetTx(tx);
             _RelayTransaction(tx.GetHash());
             m_orphanage.AddChildrenToWorkSet(tx, peer->m_id);
 
@@ -4892,8 +4950,8 @@ void PeerManagerImpl::ProcessMessage(
                 m_isman.TransactionIsRemoved(ptx);
             }
         } else {
-            m_recent_rejects.insert(tx.GetHash());
-            ForgetTx(tx.GetHash());
+            m_recent_rejects.insert(relay_hash);
+            ForgetTx(tx);
             if (RecursiveDynamicUsage(*ptx) < 100000) {
                 AddToCompactExtraTransactions(ptx);
             }
@@ -6492,7 +6550,7 @@ bool PeerManagerImpl::SendMessages(CNode* pto)
                     tx_relay->m_tx_inventory_to_send.erase(hash);
                     if (tx_relay->m_bloom_filter && !tx_relay->m_bloom_filter->IsRelevantAndUpdate(*txinfo.tx)) continue;
 
-                    int nInvType = MSG_TX;
+                    auto [nInvType, announce_hash] = GetTxAnnouncement(*txinfo.tx, pto->GetCommonVersion());
                     // A DSTX this peer would reject as malformed is announced as a plain
                     // transaction instead of being dropped: the peer still gets the transaction
                     // (ProcessGetData serves a NetMsgType::TX for it), just without the mixing
@@ -6500,8 +6558,8 @@ bool PeerManagerImpl::SendMessages(CNode* pto)
                     if (const auto dstx = m_dstxman.GetDSTX(hash); dstx && CanAnnounceDstxTo(dstx, pto->GetCommonVersion())) {
                         nInvType = MSG_DSTX;
                     }
-                    tx_relay->m_tx_inventory_known_filter.insert(hash);
-                    queueAndMaybePushInv(CInv(nInvType, hash));
+                    tx_relay->m_tx_inventory_known_filter.insert(announce_hash);
+                    queueAndMaybePushInv(CInv(nInvType, announce_hash));
 
                     const auto islock = m_isman.GetInstantSendLockByTxid(hash);
                     if (islock == nullptr) continue;
@@ -6550,17 +6608,17 @@ bool PeerManagerImpl::SendMessages(CNode* pto)
                     uint256 hash = *it;
                     // Remove it from the to-be-sent set
                     tx_relay->m_tx_inventory_to_send.erase(it);
-                    // Check if not in the filter already
-                    if (tx_relay->m_tx_inventory_known_filter.contains(hash)) {
-                        continue;
-                    }
                     // Not in the mempool anymore? don't bother sending it.
                     auto txinfo = m_mempool.info(hash);
                     if (!txinfo.tx) {
                         continue;
                     }
+                    auto [nInvType, announce_hash] = GetTxAnnouncement(*txinfo.tx, pto->GetCommonVersion());
+                    // Check if not in the filter already
+                    if (tx_relay->m_tx_inventory_known_filter.contains(announce_hash)) {
+                        continue;
+                    }
                     if (tx_relay->m_bloom_filter && !tx_relay->m_bloom_filter->IsRelevantAndUpdate(*txinfo.tx)) continue;
-                    int nInvType = MSG_TX;
                     // See the mempool-request path above: a DSTX this peer would reject as
                     // malformed is downgraded to a plain transaction announcement rather than
                     // withheld, so pre-rebalance peers still receive it.
@@ -6568,7 +6626,7 @@ bool PeerManagerImpl::SendMessages(CNode* pto)
                         nInvType = MSG_DSTX;
                     }
                     // Send
-                    State(pto->GetId())->m_recently_announced_invs.insert(hash);
+                    State(pto->GetId())->m_recently_announced_invs.insert(announce_hash);
                     nRelayedTransactions++;
                     {
                         // Expire old relay messages
@@ -6578,13 +6636,13 @@ bool PeerManagerImpl::SendMessages(CNode* pto)
                             g_relay_expiration.pop_front();
                         }
 
-                        auto ret = mapRelay.emplace(hash, std::move(txinfo.tx));
+                        auto ret = mapRelay.emplace(announce_hash, std::move(txinfo.tx));
                         if (ret.second) {
                             g_relay_expiration.emplace_back(current_time + RELAY_TX_CACHE_TIME, ret.first);
                         }
                     }
-                    tx_relay->m_tx_inventory_known_filter.insert(hash);
-                    queueAndMaybePushInv(CInv(nInvType, hash));
+                    tx_relay->m_tx_inventory_known_filter.insert(announce_hash);
+                    queueAndMaybePushInv(CInv(nInvType, announce_hash));
                 }
             }
         }
diff --git a/src/node/miner.cpp b/src/node/miner.cpp
index f40d761d46a3..4579d08fc03c 100644
--- a/src/node/miner.cpp
+++ b/src/node/miner.cpp
@@ -199,6 +199,7 @@ std::unique_ptr<CBlockTemplate> BlockAssembler::CreateNewBlock(const CScript& sc
     const bool fDIP0003Active_context{DeploymentActiveAfter(pindexPrev, chainparams.GetConsensus(), Consensus::DEPLOYMENT_DIP0003)};
     const bool fDIP0008Active_context{DeploymentActiveAfter(pindexPrev, chainparams.GetConsensus(), Consensus::DEPLOYMENT_DIP0008)};
     const bool fV20Active_context{DeploymentActiveAfter(pindexPrev, chainparams.GetConsensus(), Consensus::DEPLOYMENT_V20)};
+    const bool fV24Active_context{DeploymentActiveAfter(pindexPrev, m_chainstate.m_chainman, Consensus::DEPLOYMENT_V24)};
 
     // Limit size to between 1K and MaxBlockSize()-1K for sanity:
     m_options.nBlockMaxSize = std::max<unsigned int>(1000, std::min<unsigned int>(MaxBlockSize(fDIP0001Active_context) - 1000, m_options.nBlockMaxSize));
@@ -268,7 +269,9 @@ std::unique_ptr<CBlockTemplate> BlockAssembler::CreateNewBlock(const CScript& sc
 
         CCbTx cbTx;
 
-        if (fV20Active_context) {
+        if (fV24Active_context) {
+            cbTx.nVersion = CCbTx::Version::MERKLE_ROOT_ASSETUNLOCKS;
+        } else if (fV20Active_context) {
             cbTx.nVersion = CCbTx::Version::CLSIG_AND_BALANCE;
         } else if (fDIP0008Active_context) {
             cbTx.nVersion = CCbTx::Version::MERKLE_ROOT_QUORUMS;
@@ -304,6 +307,10 @@ std::unique_ptr<CBlockTemplate> BlockAssembler::CreateNewBlock(const CScript& sc
                 }
 
                 cbTx.creditPoolBalance = creditPoolDiff->GetTotalLocked();
+
+                if (fV24Active_context) {
+                    cbTx.merkleRootAssetUnlocks = CalcCbTxMerkleRootAssetUnlocks(*pblock);
+                }
             }
         }
 
@@ -622,6 +629,20 @@ void BlockAssembler::addPackageTxs(const CTxMemPool& mempool, int& nPackagesSele
                 }
             }
             if (tx.IsSpecialTxVersion() && (tx.nType == TRANSACTION_ASSET_LOCK || tx.nType == TRANSACTION_ASSET_UNLOCK)) {
+                // Version 2 asset unlocks are not expiry-evicted: an expired instance stays in
+                // the mempool awaiting a re-signed replacement. Skip instances that are not
+                // currently minable (expired height window or stale quorum) instead of
+                // producing an invalid template.
+                if (IsAssetUnlockWithStableTxid(tx)) {
+                    TxValidationState state;
+                    if (!m_chain_helper.special_tx->CheckSpecialTx(tx, m_chainstate.m_chain.Tip(),
+                                                                   m_chainstate.CoinsTip(), /*check_sigs=*/true, state)) {
+                        LogPrintf("%s: package tx %s skipped, asset unlock instance not currently minable: %s\n", __func__,
+                                  tx.GetHash().ToString(), state.ToString());
+                        validPackage = false;
+                        break;
+                    }
+                }
                 creditPoolTransactions.emplace_back(entry->GetSharedTx());
             }
         }
diff --git a/src/node/transaction.cpp b/src/node/transaction.cpp
index a66c036bbfda..51cc1fd8e46e 100644
--- a/src/node/transaction.cpp
+++ b/src/node/transaction.cpp
@@ -55,7 +55,13 @@ TransactionError BroadcastTransaction(NodeContext& node, const CTransactionRef t
             // So if the output does exist, then this transaction exists in the chain.
             if (!existingCoin.IsSpent()) return TransactionError::ALREADY_IN_CHAIN;
         }
-        if (auto mempool_tx = node.mempool->get(txid); mempool_tx) {
+        const auto mempool_tx = node.mempool->get(txid);
+        // A version 2 asset unlock sharing a mempool entry's txid but carrying different quorum
+        // signing info is a re-signed instance of that withdrawal and must reach the mempool,
+        // which accepts it as an in-place refresh.
+        const bool is_unlock_refresh{mempool_tx && IsAssetUnlockWithStableTxid(*tx) &&
+                                     mempool_tx->GetInstanceHash() != tx->GetInstanceHash()};
+        if (mempool_tx && !is_unlock_refresh) {
             // There's already a transaction in the mempool with this txid. Don't
             // try to submit this transaction to the mempool (since it'll be
             // rejected as a TX_CONFLICT), but do attempt to reannounce the mempool
diff --git a/src/primitives/transaction.cpp b/src/primitives/transaction.cpp
index a56f8c3677f4..04ce81e0c841 100644
--- a/src/primitives/transaction.cpp
+++ b/src/primitives/transaction.cpp
@@ -9,6 +9,7 @@
 #include <hash.h>
 #include <script/script.h>
 #include <serialize.h>
+#include <streams.h>
 #include <tinyformat.h>
 #include <uint256.h>
 #include <util/strencodings.h>
@@ -70,8 +71,26 @@ std::string CTxOut::ToString() const
 CMutableTransaction::CMutableTransaction() : nVersion(CTransaction::CURRENT_VERSION), nType(TRANSACTION_NORMAL), nLockTime(0) {}
 CMutableTransaction::CMutableTransaction(const CTransaction& tx) : vin(tx.vin), vout(tx.vout), nVersion(tx.nVersion), nType(tx.nType), nLockTime(tx.nLockTime), vExtraPayload(tx.vExtraPayload) {}
 
+namespace {
+/** The txid of a version 2+ asset unlock excludes the quorum signing info - the fields Platform
+ *  changes when it re-signs an expired withdrawal - so every re-signed instance of one withdrawal
+ *  shares one txid and spends of its outputs stay valid across re-signs. The payload is the last
+ *  field serialized (see CTransaction::Serialize), so the signing info occupies the trailing bytes
+ *  of the stream. The full-serialization hash remains available as CTransaction::GetInstanceHash()
+ *  and is committed to by the coinbase transaction. */
+template <typename TxType>
+uint256 ComputeStableUnlockHash(const TxType& tx)
+{
+    CDataStream ss(SER_GETHASH, PROTOCOL_VERSION);
+    ss << tx;
+    std::fill(ss.end() - ASSET_UNLOCK_QUORUM_INFO_SIZE, ss.end(), std::byte{0});
+    return Hash(ss);
+}
+} // anonymous namespace
+
 uint256 CMutableTransaction::GetHash() const
 {
+    if (IsAssetUnlockWithStableTxid(*this)) return ComputeStableUnlockHash(*this);
     return SerializeHash(*this);
 }
 
@@ -93,13 +112,19 @@ std::string CMutableTransaction::ToString() const
     return str;
 }
 
-uint256 CTransaction::ComputeHash() const
+uint256 CTransaction::ComputeInstanceHash() const
 {
     return SerializeHash(*this);
 }
 
-CTransaction::CTransaction(const CMutableTransaction& tx) : vin(tx.vin), vout(tx.vout), nVersion(tx.nVersion), nType(tx.nType), nLockTime(tx.nLockTime), vExtraPayload(tx.vExtraPayload), hash{ComputeHash()} {}
-CTransaction::CTransaction(CMutableTransaction&& tx) : vin(std::move(tx.vin)), vout(std::move(tx.vout)), nVersion(tx.nVersion), nType(tx.nType), nLockTime(tx.nLockTime), vExtraPayload(tx.vExtraPayload), hash{ComputeHash()} {}
+uint256 CTransaction::ComputeHash() const
+{
+    if (IsAssetUnlockWithStableTxid(*this)) return ComputeStableUnlockHash(*this);
+    return m_instance_hash;
+}
+
+CTransaction::CTransaction(const CMutableTransaction& tx) : vin(tx.vin), vout(tx.vout), nVersion(tx.nVersion), nType(tx.nType), nLockTime(tx.nLockTime), vExtraPayload(tx.vExtraPayload), m_instance_hash{ComputeInstanceHash()}, hash{ComputeHash()} {}
+CTransaction::CTransaction(CMutableTransaction&& tx) : vin(std::move(tx.vin)), vout(std::move(tx.vout)), nVersion(tx.nVersion), nType(tx.nType), nLockTime(tx.nLockTime), vExtraPayload(tx.vExtraPayload), m_instance_hash{ComputeInstanceHash()}, hash{ComputeHash()} {}
 
 CAmount CTransaction::GetValueOut() const
 {
diff --git a/src/primitives/transaction.h b/src/primitives/transaction.h
index 2a1f4a11de63..e26cf33c0cb6 100644
--- a/src/primitives/transaction.h
+++ b/src/primitives/transaction.h
@@ -36,6 +36,17 @@ enum {
     TRANSACTION_ASSET_UNLOCK = 9,
 };
 
+/** Size of the trailing payload fields holding the quorum signing info (requestedHeight,
+ *  quorumHash, quorumSig) - the only fields Platform changes when it re-signs an expired
+ *  withdrawal. */
+static constexpr size_t ASSET_UNLOCK_QUORUM_INFO_SIZE{4 + 32 + 96};
+/** Serialized size of the asset unlock (credit withdrawal) special transaction payload:
+ *  version (1) + index (8) + fee (4) + the quorum signing info. */
+static constexpr size_t ASSET_UNLOCK_PAYLOAD_SIZE{1 + 8 + 4 + ASSET_UNLOCK_QUORUM_INFO_SIZE};
+/** First asset unlock payload version whose transaction hash excludes the quorum signing info,
+ *  so that every re-signed instance of one withdrawal shares one txid. */
+static constexpr uint8_t ASSET_UNLOCK_STABLE_TXID_VERSION{2};
+
 /** An outpoint - a combination of a transaction hash and an index n into its vout */
 class COutPoint
 {
@@ -237,9 +248,13 @@ class CTransaction
     const std::vector<uint8_t> vExtraPayload; // only available for special transaction types
 
 private:
+    /** Memory only. The full-serialization hash; equal to `hash` for all transactions except
+     *  version 2+ asset unlocks, where it identifies one signed instance of the withdrawal. */
+    const uint256 m_instance_hash;
     /** Memory only. */
     const uint256 hash;
 
+    uint256 ComputeInstanceHash() const;
     uint256 ComputeHash() const;
 
 public:
@@ -269,6 +284,12 @@ class CTransaction
 
     const uint256& GetHash() const LIFETIMEBOUND { return hash; }
 
+    /** The full-serialization hash. For version 2+ asset unlocks GetHash() excludes the quorum
+     *  signing info, so this hash distinguishes the re-signed instances of one withdrawal; it is
+     *  used for their relay and for the coinbase asset unlock commitment. Equal to GetHash() for
+     *  all other transactions. */
+    const uint256& GetInstanceHash() const LIFETIMEBOUND { return m_instance_hash; }
+
     // Return sum of txouts.
     CAmount GetValueOut() const;
 
@@ -351,6 +372,17 @@ struct CMutableTransaction
     std::string ToString() const;
 };
 
+/** Whether this (mutable or immutable) transaction is an asset unlock whose hash is computed with
+ *  the quorum signing info zeroed (payload version 2 or higher). Judged from the raw payload bytes
+ *  because hashing happens before payload validation. */
+template <typename TxType>
+inline bool IsAssetUnlockWithStableTxid(const TxType& tx)
+{
+    return tx.nVersion >= CTransaction::SPECIAL_VERSION && tx.nType == TRANSACTION_ASSET_UNLOCK &&
+           tx.vExtraPayload.size() == ASSET_UNLOCK_PAYLOAD_SIZE &&
+           tx.vExtraPayload[0] >= ASSET_UNLOCK_STABLE_TXID_VERSION;
+}
+
 typedef std::shared_ptr<const CTransaction> CTransactionRef;
 template <typename Tx> static inline CTransactionRef MakeTransactionRef(Tx&& txIn) { return std::make_shared<const CTransaction>(std::forward<Tx>(txIn)); }
 
diff --git a/src/protocol.cpp b/src/protocol.cpp
index c5683a16dc9d..180649352341 100644
--- a/src/protocol.cpp
+++ b/src/protocol.cpp
@@ -300,6 +300,9 @@ const char* CInv::GetCommandInternal() const
         case MSG_ISDLOCK:                       return NetMsgType::ISDLOCK;
         case MSG_DSQ:                           return NetMsgType::DSQUEUE;
         case MSG_PLATFORM_BAN:                  return NetMsgType::PLATFORMBAN;
+        // Version 2 asset unlocks are announced by instance hash but carried in plain `tx`
+        // messages; this also puts them in the blocks-only violation list, like MSG_TX
+        case MSG_ASSET_UNLOCK:                  return NetMsgType::TX;
         default:
             return nullptr;
     }
diff --git a/src/protocol.h b/src/protocol.h
index 6e39faa23dd0..d616c06f56fc 100644
--- a/src/protocol.h
+++ b/src/protocol.h
@@ -524,6 +524,7 @@ enum GetDataMsg : uint32_t {
     MSG_ISDLOCK = 31,
     MSG_DSQ = 32,
     MSG_PLATFORM_BAN = 33,                            // Platform service ban (DIP-0031)
+    MSG_ASSET_UNLOCK = 34,                            //!< Version 2 asset unlock announced by instance hash; getdata is answered with a `tx` message
 };
 
 /** inv message data */
@@ -546,13 +547,14 @@ class CInv
     bool IsMsgTx()        const { return type == MSG_TX; }
     bool IsMsgBlk() const { return type == MSG_BLOCK; }
     bool IsMsgDstx()       const { return type == MSG_DSTX; }
+    bool IsMsgAssetUnlock() const { return type == MSG_ASSET_UNLOCK; }
     bool IsMsgFilteredBlk() const { return type == MSG_FILTERED_BLOCK; }
     bool IsMsgCmpctBlk() const { return type == MSG_CMPCT_BLOCK; }
 
     // Combined-message helper methods
     bool IsGenTxMsg() const
     {
-        return type == MSG_TX || type == MSG_DSTX;
+        return type == MSG_TX || type == MSG_DSTX || type == MSG_ASSET_UNLOCK;
     }
     bool IsGenBlkMsg() const
     {
diff --git a/src/rpc/json_help.cpp b/src/rpc/json_help.cpp
index 8bae35f01a2e..3c1a8682369b 100644
--- a/src/rpc/json_help.cpp
+++ b/src/rpc/json_help.cpp
@@ -140,6 +140,7 @@ RPCResult CCbTx::GetJsonHelp(const std::string& key, bool optional)
         {RPCResult::Type::NUM, "bestCLHeightDiff", /*optional=*/true, "Blocks between the current block and the last known block with a ChainLock"},
         {RPCResult::Type::STR_HEX, "bestCLSignature", /*optional=*/true, "Best ChainLock signature known by the miner"},
         {RPCResult::Type::NUM, "creditPoolBalance", /*optional=*/true, "Balance in the Platform credit pool"},
+        {RPCResult::Type::STR_HEX, "merkleRootAssetUnlocks", /*optional=*/true, "Merkle root of the instance hashes of the block's version 2 asset unlock transactions"},
     }};
 }
 
diff --git a/src/rpc/quorums.cpp b/src/rpc/quorums.cpp
index 5bd168e9b0bf..2dc5620a80b5 100644
--- a/src/rpc/quorums.cpp
+++ b/src/rpc/quorums.cpp
@@ -536,7 +536,12 @@ static UniValue quorum_sign_helper(const JSONRPCRequest& request, Consensus::LLM
                            "Quorum signing is disabled until snapshot background validation completes");
     }
     if (fSubmit) {
-        return CHECK_NONFATAL(node.active_ctx)->shareman->AsyncSignIfMember(llmqType, id, msgHash, quorumHash);
+        // Platform re-signs expired withdrawals under the same request id with a new message
+        // hash, so platform-type sessions must not refuse a changed message
+        const bool allow_diff_msghash{llmqType == Params().GetConsensus().llmqTypePlatform};
+        return CHECK_NONFATAL(node.active_ctx)
+            ->shareman->AsyncSignIfMember(llmqType, id, msgHash, quorumHash, /*allowReSign=*/false,
+                                          /*allowDiffMsgHashSigning=*/allow_diff_msghash);
     } else {
         const auto pQuorum = [&]() {
             if (quorumHash.IsNull()) {
diff --git a/src/rpc/rawtransaction.cpp b/src/rpc/rawtransaction.cpp
index 9d55adcc00cb..34527f5baf70 100644
--- a/src/rpc/rawtransaction.cpp
+++ b/src/rpc/rawtransaction.cpp
@@ -221,6 +221,7 @@ static std::vector<RPCResult> DecodeTxDoc(const std::string& txid_field_doc)
         MNHFTxPayload::GetJsonHelp(/*key=*/"mnhfTx", /*optional=*/true),
         CAssetLockPayload::GetJsonHelp(/*key=*/"assetLockTx", /*optional=*/true),
         CAssetUnlockPayload::GetJsonHelp(/*key=*/"assetUnlockTx", /*optional=*/true),
+        {RPCResult::Type::STR_HEX, "instanceHash", /*optional=*/true, "Full-serialization hash distinguishing this re-signed instance of the withdrawal; the txid is shared by all instances. Only present for version 2 Asset Unlock special TXs"},
     };
 }
 
diff --git a/src/test/evo_assetlocks_tests.cpp b/src/test/evo_assetlocks_tests.cpp
index d3f7e9f41d9c..1fc0d396a510 100644
--- a/src/test/evo_assetlocks_tests.cpp
+++ b/src/test/evo_assetlocks_tests.cpp
@@ -8,6 +8,7 @@
 #include <consensus/tx_check.h>
 #include <consensus/validation.h>
 #include <evo/assetlocktx.h>
+#include <evo/cbtx.h>
 #include <evo/creditpool.h>
 #include <evo/specialtx.h>
 #include <llmq/context.h>
@@ -429,7 +430,7 @@ BOOST_FIXTURE_TEST_CASE(evo_assetunlock, TestChain100Setup)
     auto& qman = *Assert(m_node.llmq_ctx)->qman;
 
     const CBlockIndex *block_index = m_node.chainman->ActiveChain().Tip();
-    BOOST_CHECK(!CheckAssetUnlockTx(blockman, qman, CTransaction(tx), block_index, std::nullopt, tx_state));
+    BOOST_CHECK(!CheckAssetUnlockTx(blockman, qman, CTransaction(tx), block_index, std::nullopt, /*is_v24_active=*/true, tx_state));
     BOOST_CHECK(tx_state.GetRejectReason() == "bad-assetunlock-quorum-hash");
 
     {
@@ -447,7 +448,7 @@ BOOST_FIXTURE_TEST_CASE(evo_assetunlock, TestChain100Setup)
         std::string reason;
         BOOST_CHECK(IsStandardTx(CTransaction(tx), reason));
 
-        BOOST_CHECK(!CheckAssetUnlockTx(blockman, qman, CTransaction(txNonemptyInput), block_index, std::nullopt, tx_state));
+        BOOST_CHECK(!CheckAssetUnlockTx(blockman, qman, CTransaction(txNonemptyInput), block_index, std::nullopt, /*is_v24_active=*/true, tx_state));
         BOOST_CHECK(tx_state.GetRejectReason() == "bad-assetunlocktx-have-input");
     }
 
@@ -462,7 +463,7 @@ BOOST_FIXTURE_TEST_CASE(evo_assetunlock, TestChain100Setup)
         // Wrong type "Asset Lock TX" instead "Asset Unlock TX"
         CMutableTransaction txWrongType(tx);
         txWrongType.nType = TRANSACTION_ASSET_LOCK;
-        BOOST_CHECK(!CheckAssetUnlockTx(blockman, qman, CTransaction(txWrongType), block_index, std::nullopt, tx_state));
+        BOOST_CHECK(!CheckAssetUnlockTx(blockman, qman, CTransaction(txWrongType), block_index, std::nullopt, /*is_v24_active=*/true, tx_state));
         BOOST_CHECK(tx_state.GetRejectReason() == "bad-assetunlocktx-type");
 
         // Check version of tx and payload
@@ -476,16 +477,101 @@ BOOST_FIXTURE_TEST_CASE(evo_assetunlock, TestChain100Setup)
                 unlockPayload->getQuorumSig()};
             CMutableTransaction txWrongVersion(tx);
             SetTxPayload(txWrongVersion, unlockPayload_tmp);
-            if (payload_version != 1) {
-                BOOST_CHECK(!CheckAssetUnlockTx(blockman, qman, CTransaction(txWrongVersion), block_index, std::nullopt, tx_state));
+            if (payload_version == 0 || payload_version > CAssetUnlockPayload::CURRENT_VERSION) {
+                BOOST_CHECK(!CheckAssetUnlockTx(blockman, qman, CTransaction(txWrongVersion), block_index, std::nullopt, /*is_v24_active=*/true, tx_state));
                 BOOST_CHECK(tx_state.GetRejectReason() == "bad-assetunlocktx-version");
+            } else if (payload_version == 2) {
+                BOOST_CHECK(!CheckAssetUnlockTx(blockman, qman, CTransaction(txWrongVersion), block_index, std::nullopt, /*is_v24_active=*/false, tx_state));
+                BOOST_CHECK(tx_state.GetRejectReason() == "bad-assetunlocktx-version-2");
+                BOOST_CHECK(!CheckAssetUnlockTx(blockman, qman, CTransaction(txWrongVersion), block_index, std::nullopt, /*is_v24_active=*/true, tx_state));
+                BOOST_CHECK(tx_state.GetRejectReason() == "bad-assetunlock-quorum-hash");
             } else {
-                BOOST_CHECK(!CheckAssetUnlockTx(blockman, qman, CTransaction(txWrongVersion), block_index, std::nullopt, tx_state));
+                // Version 1 must not hit the version-2 gate regardless of v24 state
+                BOOST_CHECK(!CheckAssetUnlockTx(blockman, qman, CTransaction(txWrongVersion), block_index, std::nullopt, /*is_v24_active=*/false, tx_state));
+                BOOST_CHECK(tx_state.GetRejectReason() == "bad-assetunlock-quorum-hash");
+                BOOST_CHECK(!CheckAssetUnlockTx(blockman, qman, CTransaction(txWrongVersion), block_index, std::nullopt, /*is_v24_active=*/true, tx_state));
                 BOOST_CHECK(tx_state.GetRejectReason() == "bad-assetunlock-quorum-hash");
             }
         }
     }
 
+    {
+        // The txid of a version 2 payload is invariant across the quorum signing info - the fields
+        // Platform changes on re-sign - and nothing else; the instance hash still covers them
+        const auto unlockPayload = GetTxPayload<CAssetUnlockPayload>(tx);
+        BOOST_CHECK(unlockPayload.has_value());
+
+        auto make_unlock_tx = [&](uint8_t version, uint64_t index, uint32_t fee, uint32_t requested_height,
+                                  const uint256& quorum_hash) {
+            CMutableTransaction tx_tmp(tx);
+            SetTxPayload(tx_tmp, CAssetUnlockPayload{version, index, fee, requested_height, quorum_hash,
+                                                     unlockPayload->getQuorumSig()});
+            return CTransaction(tx_tmp);
+        };
+
+        // Version 1 hashes the full serialization
+        const CTransaction tx_v1{make_unlock_tx(1, 0x11, 2000, 500, uint256::ONE)};
+        BOOST_CHECK(!IsAssetUnlockWithStableTxid(tx_v1));
+        BOOST_CHECK(tx_v1.GetHash() == tx_v1.GetInstanceHash());
+        BOOST_CHECK(tx_v1.GetHash() == ::SerializeHash(tx_v1));
+
+        const CTransaction tx_v2{make_unlock_tx(2, 0x11, 2000, 500, uint256::ONE)};
+        BOOST_CHECK(IsAssetUnlockWithStableTxid(tx_v2));
+        BOOST_CHECK(tx_v2.vExtraPayload.size() == ASSET_UNLOCK_PAYLOAD_SIZE);
+        BOOST_CHECK(tx_v2.GetHash() != tx_v2.GetInstanceHash());
+        BOOST_CHECK(tx_v2.GetInstanceHash() == ::SerializeHash(tx_v2));
+
+        // Re-signing changes requestedHeight and quorumHash but not the txid; the instance
+        // hash tells the two instances apart
+        const CTransaction tx_v2_resigned{make_unlock_tx(2, 0x11, 2000, 700, uint256::TWO)};
+        BOOST_CHECK(tx_v2_resigned.GetHash() == tx_v2.GetHash());
+        BOOST_CHECK(tx_v2_resigned.GetInstanceHash() != tx_v2.GetInstanceHash());
+        // A different withdrawal (index or fee) has a different txid
+        BOOST_CHECK(make_unlock_tx(2, 0x12, 2000, 500, uint256::ONE).GetHash() != tx_v2.GetHash());
+        BOOST_CHECK(make_unlock_tx(2, 0x11, 3000, 500, uint256::ONE).GetHash() != tx_v2.GetHash());
+
+        // CMutableTransaction applies the same rule
+        BOOST_CHECK(CMutableTransaction(tx_v2).GetHash() == tx_v2.GetHash());
+
+        // The txid equals the full-serialization hash with the quorum signing info zeroed
+        CMutableTransaction tx_zeroed(tx_v2);
+        SetTxPayload(tx_zeroed, CAssetUnlockPayload{2, 0x11, 2000, /*requestedHeight=*/0,
+                                                    /*quorumHash=*/uint256(), CBLSSignature{}});
+        BOOST_CHECK(::SerializeHash(tx_zeroed) == tx_v2.GetHash());
+
+        // The signed message zeroes only quorumSig: it commits to the signing info even though
+        // the txid does not, and must never be computed with GetHash()
+        auto msg_hash = [](const CTransaction& t) {
+            const auto p = GetTxPayload<CAssetUnlockPayload>(t);
+            CMutableTransaction copy(t);
+            SetTxPayload(copy, CAssetUnlockPayload{p->getVersion(), p->getIndex(), p->getFee(),
+                                                   p->getRequestedHeight(), p->getQuorumHash(), CBLSSignature{}});
+            return ::SerializeHash(copy);
+        };
+        BOOST_CHECK(msg_hash(tx_v2) != msg_hash(tx_v2_resigned));
+        BOOST_CHECK(msg_hash(tx_v2) != tx_v2.GetHash());
+    }
+
+    {
+        // DIP-0027 worked examples for the version 2 txid (dip-0027/dip-0027-txid-calc.py)
+        auto dip_example_tx = [](uint64_t index) {
+            CMutableTransaction tx_dip;
+            tx_dip.nVersion = 3;
+            tx_dip.nType = TRANSACTION_ASSET_UNLOCK;
+            uint160 pubkey_hash;
+            std::fill(pubkey_hash.begin(), pubkey_hash.end(), 0x11);
+            const CScript script{GetScriptForDestination(PKHash{pubkey_hash})};
+            tx_dip.vout.emplace_back(100000000, script);
+            SetTxPayload(tx_dip, CAssetUnlockPayload{2, index, /*fee=*/70000, /*requestedHeight=*/500,
+                                                     uint256::ONE, CBLSSignature{}});
+            return CTransaction(tx_dip);
+        };
+        BOOST_CHECK_EQUAL(dip_example_tx(101).GetHash().ToString(),
+                          "3c4db73c8356407a5d7c78df5045bd280f2dc4fd644b06c4bfbdead3d5ae41cf");
+        BOOST_CHECK_EQUAL(dip_example_tx(123456789).GetHash().ToString(),
+                          "a67e1107ae6e04b813bc8e81348266f5206d1ca93d305dc4323940e18cdbaf34");
+    }
+
     {
         // Exactly 32 withdrawal is fine
         CMutableTransaction txManyOutputs(tx);
@@ -496,15 +582,15 @@ BOOST_FIXTURE_TEST_CASE(evo_assetunlock, TestChain100Setup)
             out.scriptPubKey = GetScriptForDestination(PKHash(key.GetPubKey()));
         }
 
-        BOOST_CHECK(!CheckAssetUnlockTx(blockman, qman, CTransaction(txManyOutputs), block_index, std::nullopt, tx_state));
+        BOOST_CHECK(!CheckAssetUnlockTx(blockman, qman, CTransaction(txManyOutputs), block_index, std::nullopt, /*is_v24_active=*/true, tx_state));
         BOOST_CHECK(tx_state.GetRejectReason() == "bad-assetunlock-quorum-hash");
 
         // Basic checks for CRangesSet
         CRangesSet indexes;
-        BOOST_CHECK(!CheckAssetUnlockTx(blockman, qman, CTransaction(txManyOutputs), block_index, indexes, tx_state));
+        BOOST_CHECK(!CheckAssetUnlockTx(blockman, qman, CTransaction(txManyOutputs), block_index, indexes, /*is_v24_active=*/true, tx_state));
         BOOST_CHECK(tx_state.GetRejectReason() == "bad-assetunlock-quorum-hash");
         BOOST_CHECK(indexes.Add(0x001122334455667788L));
-        BOOST_CHECK(!CheckAssetUnlockTx(blockman, qman, CTransaction(txManyOutputs), block_index, indexes, tx_state));
+        BOOST_CHECK(!CheckAssetUnlockTx(blockman, qman, CTransaction(txManyOutputs), block_index, indexes, /*is_v24_active=*/true, tx_state));
         BOOST_CHECK(tx_state.GetRejectReason() == "bad-assetunlock-duplicated-index");
 
 
@@ -512,12 +598,43 @@ BOOST_FIXTURE_TEST_CASE(evo_assetunlock, TestChain100Setup)
         txManyOutputs.vout.resize(outputsLimit + 1);
         txManyOutputs.vout.back().nValue = CENT;
         txManyOutputs.vout.back().scriptPubKey = GetScriptForDestination(PKHash(key.GetPubKey()));
-        BOOST_CHECK(!CheckAssetUnlockTx(blockman, qman, CTransaction(txManyOutputs), block_index, std::nullopt, tx_state));
+        BOOST_CHECK(!CheckAssetUnlockTx(blockman, qman, CTransaction(txManyOutputs), block_index, std::nullopt, /*is_v24_active=*/true, tx_state));
         BOOST_CHECK(tx_state.GetRejectReason() == "bad-assetunlocktx-too-many-outs");
     }
 
 }
 
+BOOST_FIXTURE_TEST_CASE(evo_assetunlock_cbtx_merkle_root, BasicTestingSetup)
+{
+    auto make_unlock = [](uint8_t version, uint64_t index, uint32_t requested_height) {
+        CMutableTransaction mtx;
+        mtx.nVersion = 3;
+        mtx.nType = TRANSACTION_ASSET_UNLOCK;
+        SetTxPayload(mtx, CAssetUnlockPayload{version, index, /*fee=*/2000, requested_height,
+                                              uint256::ONE, CBLSSignature{}});
+        return MakeTransactionRef(mtx);
+    };
+
+    // Only version 2 unlocks are committed to; a block without them commits to null
+    CBlock block;
+    block.vtx.push_back(make_unlock(1, 1, 500));
+    BOOST_CHECK(CalcCbTxMerkleRootAssetUnlocks(block).IsNull());
+
+    const auto unlock_a = make_unlock(2, 1, 500);
+    block.vtx.push_back(unlock_a);
+    const uint256 root_one{CalcCbTxMerkleRootAssetUnlocks(block)};
+    BOOST_CHECK(root_one == unlock_a->GetInstanceHash());
+
+    block.vtx.push_back(make_unlock(2, 2, 500));
+    const uint256 root_two{CalcCbTxMerkleRootAssetUnlocks(block)};
+    BOOST_CHECK(root_two != root_one);
+
+    // A different re-signed instance keeps the txid but changes the committed root
+    block.vtx.back() = make_unlock(2, 2, 700);
+    BOOST_CHECK(block.vtx.back()->GetHash() == make_unlock(2, 2, 500)->GetHash());
+    BOOST_CHECK(CalcCbTxMerkleRootAssetUnlocks(block) != root_two);
+}
+
 BOOST_FIXTURE_TEST_CASE(credit_pool_package_atomicity, TestChain100Setup)
 {
     LOCK(cs_main);
diff --git a/src/test/util/setup_common.cpp b/src/test/util/setup_common.cpp
index 7a1d2adb99d7..0b1f2f106d65 100644
--- a/src/test/util/setup_common.cpp
+++ b/src/test/util/setup_common.cpp
@@ -592,6 +592,9 @@ CBlock TestChainSetup::CreateBlock(
         if (!CalcCbTxMerkleRootQuorums(block, chainstate.m_chain.Tip(), *m_node.llmq_ctx->quorum_block_processor, cbTx->merkleRootQuorums, state)) {
             Assert(false);
         }
+        if (cbTx->nVersion >= CCbTx::Version::MERKLE_ROOT_ASSETUNLOCKS) {
+            cbTx->merkleRootAssetUnlocks = CalcCbTxMerkleRootAssetUnlocks(block);
+        }
         CMutableTransaction tmpTx{*block.vtx[0]};
         SetTxPayload(tmpTx, *cbTx);
         block.vtx[0] = MakeTransactionRef(tmpTx);
diff --git a/src/txmempool.cpp b/src/txmempool.cpp
index a7754ea05052..939417e6c7e6 100644
--- a/src/txmempool.cpp
+++ b/src/txmempool.cpp
@@ -504,7 +504,7 @@ void CTxMemPool::addUnchecked(const CTxMemPoolEntry &entry, setEntries &setAnces
         minerPolicyEstimator->processTransaction(entry, validFeeEstimate);
     }
 
-    vTxHashes.emplace_back(entry.GetTx().GetHash(), newit);
+    vTxHashes.emplace_back(entry.GetTx().GetInstanceHash(), newit);
     newit->vTxHashesIdx = vTxHashes.size() - 1;
 
     // Invalid ProTxes should never get this far because transactions should be
@@ -684,8 +684,15 @@ void CTxMemPool::addUncheckedProTx(indexed_transaction_set::iterator& newit, con
             newit->isKeyChangeProTx = true;
         }
     } else if (tx.nType == TRANSACTION_ASSET_UNLOCK) {
-        auto assetUnlockTx = *Assert(GetTxPayload<CAssetUnlockPayload>(tx));
-        mapAssetUnlockExpiry.insert({tx_hash, assetUnlockTx.getHeightToExpiry()});
+        if (IsAssetUnlockWithStableTxid(tx)) {
+            // Re-signed instances of one withdrawal share the txid. The withdrawal is kept while
+            // expired, awaiting a fresher instance, instead of being expiry-evicted (which would
+            // take its descendants with it); relay identifies instances by instance hash.
+            m_asset_unlock_instances.emplace(tx.GetInstanceHash(), tx_hash);
+        } else {
+            auto assetUnlockTx = *Assert(GetTxPayload<CAssetUnlockPayload>(tx));
+            mapAssetUnlockExpiry.insert({tx_hash, assetUnlockTx.getHeightToExpiry()});
+        }
     } else if (tx.nType == TRANSACTION_MNHF_SIGNAL) {
         PrioritiseTransaction(tx_hash, 0.1 * COIN);
     }
@@ -779,10 +786,39 @@ void CTxMemPool::removeUncheckedProTx(const CTransaction& tx)
         auto proTx = *Assert(GetTxPayload<CProUpRevTx>(tx));
         eraseProTxRef(proTx.proTxHash, tx_hash);
     } else if (tx.nType == TRANSACTION_ASSET_UNLOCK) {
-        mapAssetUnlockExpiry.erase(tx_hash);
+        if (IsAssetUnlockWithStableTxid(tx)) {
+            m_asset_unlock_instances.erase(tx.GetInstanceHash());
+        } else {
+            mapAssetUnlockExpiry.erase(tx_hash);
+        }
     }
 }
 
+CTransactionRef CTxMemPool::GetAssetUnlockByInstanceHash(const uint256& instance_hash) const
+{
+    LOCK(cs);
+    auto it = m_asset_unlock_instances.find(instance_hash);
+    if (it == m_asset_unlock_instances.end()) return nullptr;
+    return get(it->second);
+}
+
+void CTxMemPool::ReplaceAssetUnlockInstance(const CTransactionRef& tx)
+{
+    AssertLockHeld(cs);
+    auto it = mapTx.find(tx->GetHash());
+    assert(it != mapTx.end());
+    const uint256 old_instance_hash{it->GetTx().GetInstanceHash()};
+    // Sharing a txid implies everything but the quorum signing info is identical, so all cached
+    // entry values (size, fee, ancestry) and multi-index keys remain valid; modify() cannot fail.
+    Assume(it->GetTx().GetTotalSize() == tx->GetTotalSize());
+    const bool modified{mapTx.modify(it, [&tx](CTxMemPoolEntry& e) { e.ReplaceAssetUnlockTx(tx); })};
+    assert(modified);
+    vTxHashes[it->vTxHashesIdx].first = tx->GetInstanceHash();
+    m_asset_unlock_instances.erase(old_instance_hash);
+    m_asset_unlock_instances.emplace(tx->GetInstanceHash(), tx->GetHash());
+    nTransactionsUpdated++;
+}
+
 // Calculates descendants of entry that are not already in setDescendants, and adds to
 // setDescendants. Assumes entryit is already a tx in the mempool and CTxMemPoolEntry::m_children
 // is correct for tx and all descendants.
@@ -1137,6 +1173,7 @@ void CTxMemPool::_clear()
     mapProTxAddresses.clear();
     mapProTxPubKeyIDs.clear();
     mapProTxPlatformNodeIDs.clear();
+    m_asset_unlock_instances.clear();
     totalTxSize = 0;
     m_total_fee = 0;
     cachedInnerUsage = 0;
@@ -1166,6 +1203,7 @@ void CTxMemPool::check(const CCoinsViewCache& active_coins_tip, int64_t spendhei
     CAmount check_total_fee{0};
     uint64_t innerUsage = 0;
     uint64_t prev_ancestor_count{0};
+    size_t check_asset_unlock_instances{0};
 
     CCoinsViewCache mempoolDuplicate(const_cast<CCoinsViewCache*>(&active_coins_tip));
 
@@ -1175,6 +1213,12 @@ void CTxMemPool::check(const CCoinsViewCache& active_coins_tip, int64_t spendhei
         innerUsage += it->DynamicMemoryUsage();
         const CTransaction& tx = it->GetTx();
         innerUsage += memusage::DynamicUsage(it->GetMemPoolParentsConst()) + memusage::DynamicUsage(it->GetMemPoolChildrenConst());
+        if (IsAssetUnlockWithStableTxid(tx)) {
+            ++check_asset_unlock_instances;
+            auto instance_it = m_asset_unlock_instances.find(tx.GetInstanceHash());
+            assert(instance_it != m_asset_unlock_instances.end());
+            assert(instance_it->second == tx.GetHash());
+        }
         CTxMemPoolEntry::Parents setParentCheck;
         for (const CTxIn &txin : tx.vin) {
             // Check that every mempool transaction's inputs refer to available coins, or other mempool tx's.
@@ -1257,6 +1301,7 @@ void CTxMemPool::check(const CCoinsViewCache& active_coins_tip, int64_t spendhei
     assert(totalTxSize == checkTotal);
     assert(m_total_fee == check_total_fee);
     assert(innerUsage == cachedInnerUsage);
+    assert(check_asset_unlock_instances == m_asset_unlock_instances.size());
 }
 
 bool CTxMemPool::CompareDepthAndScore(const uint256& hasha, const uint256& hashb)
diff --git a/src/txmempool.h b/src/txmempool.h
index 429a4d2a44ed..3d5ae769ce79 100644
--- a/src/txmempool.h
+++ b/src/txmempool.h
@@ -30,6 +30,7 @@
 #include <pubkey.h>
 #include <random.h>
 #include <sync.h>
+#include <util/check.h>
 #include <util/epochguard.h>
 #include <util/hasher.h>
 
@@ -110,7 +111,7 @@ class CTxMemPoolEntry
     struct ExplicitCopyTag {
         explicit ExplicitCopyTag() = default;
     };
-    const CTransactionRef tx;
+    CTransactionRef tx; //!< Only replaced by ReplaceAssetUnlockTx(), which preserves the txid
     mutable Parents m_parents;
     mutable Children m_children;
     const CAmount nFee;             //!< Cached to avoid expensive parent-transaction lookups
@@ -150,6 +151,13 @@ class CTxMemPoolEntry
     static constexpr ExplicitCopyTag ExplicitCopy{};
     const CTransaction& GetTx() const { return *this->tx; }
     CTransactionRef GetSharedTx() const { return this->tx; }
+    /** Swap in a re-signed instance of a version 2 asset unlock sharing this entry's txid. The
+     *  instances differ only in the quorum signing info, so all cached values remain valid. */
+    void ReplaceAssetUnlockTx(CTransactionRef new_tx)
+    {
+        Assume(new_tx->GetHash() == tx->GetHash());
+        tx = std::move(new_tx);
+    }
     const CAmount& GetFee() const { return nFee; }
     size_t GetTxSize() const;
     std::chrono::seconds GetTime() const { return std::chrono::seconds{nTime}; }
@@ -528,7 +536,7 @@ class CTxMemPool
     indexed_transaction_set mapTx GUARDED_BY(cs);
 
     using txiter = indexed_transaction_set::nth_index<0>::type::const_iterator;
-    std::vector<std::pair<uint256, txiter> > vTxHashes GUARDED_BY(cs); //!< All tx hashes/entries in mapTx, in random order
+    std::vector<std::pair<uint256, txiter> > vTxHashes GUARDED_BY(cs); //!< All tx instance hashes (see CTransaction::GetInstanceHash)/entries in mapTx, in random order
 
     typedef std::set<txiter, CompareIteratorByHash> setEntries;
 
@@ -549,7 +557,10 @@ class CTxMemPool
     std::map<uint256, uint256> mapProTxBlsPubKeyHashes;
     std::map<uint160, uint256> mapProTxPlatformNodeIDs;
     std::map<COutPoint, uint256> mapProTxCollaterals;
-    std::map<uint256, int /* expiry height */> mapAssetUnlockExpiry; // tx hash -> height
+    std::map<uint256, int /* expiry height */> mapAssetUnlockExpiry; // tx hash -> height (version 1 only)
+    /** Instance hash (see CTransaction::GetInstanceHash) -> txid of version 2+ asset unlocks.
+     *  Relay identifies the re-signed instances of one withdrawal by instance hash. */
+    std::map<uint256, uint256> m_asset_unlock_instances GUARDED_BY(cs);
 
     void UpdateParent(txiter entry, txiter parent, bool add) EXCLUSIVE_LOCKS_REQUIRED(cs);
     void UpdateChild(txiter entry, txiter child, bool add) EXCLUSIVE_LOCKS_REQUIRED(cs);
@@ -820,6 +831,12 @@ class CTxMemPool
     TxMempoolInfo info(const uint256& hash) const;
     std::vector<TxMempoolInfo> infoAll() const;
 
+    /** Get the transaction holding this version 2 asset unlock instance hash, if any. */
+    CTransactionRef GetAssetUnlockByInstanceHash(const uint256& instance_hash) const;
+    /** Replace the held instance of a pending withdrawal with a fresher re-signed instance
+     *  sharing its txid. The caller has fully validated the new instance. */
+    void ReplaceAssetUnlockInstance(const CTransactionRef& tx) EXCLUSIVE_LOCKS_REQUIRED(cs);
+
     bool existsProviderTxConflict(const CTransaction &tx) const;
 
     /**
diff --git a/src/validation.cpp b/src/validation.cpp
index e1cc33d909ac..5178bf052bc4 100644
--- a/src/validation.cpp
+++ b/src/validation.cpp
@@ -54,7 +54,10 @@
 #include <warnings.h>
 
 #include <chainlock/chainlock.h>
+#include <evo/assetlocktx.h>
+#include <evo/cbtx.h>
 #include <evo/chainhelper.h>
+#include <evo/creditpool.h>
 #include <evo/deterministicmns.h>
 #include <evo/evodb.h>
 #include <evo/specialtx.h>
@@ -724,6 +727,12 @@ class MemPoolAccept
     // only tests that are fast should be done here (to avoid CPU DoS).
     bool PreChecks(ATMPArgs& args, Workspace& ws) EXCLUSIVE_LOCKS_REQUIRED(cs_main, m_pool.cs);
 
+    // If ptx is a version 2 asset unlock whose txid is already in the mempool, handle it as a
+    // re-signed instance of that withdrawal: validate it and, when fresher, swap it into the
+    // existing entry in place. Returns std::nullopt when the normal acceptance path should run.
+    std::optional<MempoolAcceptResult> TryAssetUnlockRefresh(const CTransactionRef& ptx, const ATMPArgs& args)
+        EXCLUSIVE_LOCKS_REQUIRED(cs_main, m_pool.cs);
+
     // Enforce package mempool ancestor/descendant limits (distinct from individual
     // ancestor/descendant limits done in PreChecks).
     bool PackageMempoolChecks(const std::vector<CTransactionRef>& txns,
@@ -873,6 +882,19 @@ bool MemPoolAccept::PreChecks(ATMPArgs& args, Workspace& ws)
     m_view.SetBackend(m_viewmempool);
 
     const CCoinsViewCache& coins_cache = m_active_chainstate.CoinsTip();
+
+    // Asset unlocks have no inputs, so the missing-inputs check below cannot detect that this
+    // withdrawal was already mined - and a coin check is not reliable either, since the outputs
+    // may have been spent in the very block that mined it. The credit pool's mined-index set is
+    // authoritative. Version 2 unlocks are never expiry-evicted, so an already-mined instance
+    // admitted here would linger indefinitely. GetCreditPool reads from an LRU cache; the first
+    // call after startup may reconstruct the pool from the nearest disk snapshot.
+    if (const auto opt_unlock = tx.IsPlatformTransfer() ? GetTxPayload<CAssetUnlockPayload>(tx) : std::nullopt;
+        opt_unlock && m_chain_helper.credit_pool_manager->GetCreditPool(m_active_chainstate.m_chain.Tip())
+                          .indexes.Contains(opt_unlock->getIndex())) {
+        return state.Invalid(TxValidationResult::TX_CONFLICT, "txn-already-known");
+    }
+
     // do all inputs exist?
     for (const CTxIn& txin : tx.vin) {
         if (!coins_cache.HaveCoinInCache(txin.prevout)) {
@@ -1220,12 +1242,62 @@ bool MemPoolAccept::SubmitPackage(const ATMPArgs& args, std::vector<Workspace>&
     return all_submitted;
 }
 
+std::optional<MempoolAcceptResult> MemPoolAccept::TryAssetUnlockRefresh(const CTransactionRef& ptx, const ATMPArgs& args)
+{
+    AssertLockHeld(cs_main);
+    AssertLockHeld(m_pool.cs);
+
+    if (!IsAssetUnlockWithStableTxid(*ptx)) return std::nullopt;
+    const auto held_it = m_pool.GetIter(ptx->GetHash());
+    if (!held_it) return std::nullopt;
+    const CTransactionRef held = (*held_it)->GetSharedTx();
+
+    TxValidationState state;
+    if (held->GetInstanceHash() == ptx->GetInstanceHash()) {
+        state.Invalid(TxValidationResult::TX_CONFLICT, "txn-already-in-mempool");
+        return MempoolAcceptResult::Failure(state);
+    }
+
+    const auto held_payload = GetTxPayload<CAssetUnlockPayload>(*held);
+    const auto new_payload = GetTxPayload<CAssetUnlockPayload>(*ptx);
+    // Reject cheaply, before any signature work, unless this is a plausibly minable fresher
+    // instance: its requestedHeight must strictly exceed the held instance's and place the tip
+    // inside the withdrawal's validity window. This bounds how much quorum-signature verification
+    // a peer can force by resubmitting instances that share the mempool entry's txid.
+    const int tip_height = m_active_chainstate.m_chain.Height();
+    if (!Assume(held_payload) || !new_payload ||
+        new_payload->getRequestedHeight() <= held_payload->getRequestedHeight() ||
+        static_cast<int64_t>(new_payload->getRequestedHeight()) > tip_height ||
+        new_payload->getHeightToExpiry() <= tip_height) {
+        state.Invalid(TxValidationResult::TX_CONFLICT, "assetunlock-stale-instance");
+        return MempoolAcceptResult::Failure(state);
+    }
+
+    // Full consensus validation of the fresh instance: payload, quorum recency, height window
+    // and quorum signature. Everything the txid covers is identical to the held instance and
+    // was validated when it was admitted.
+    if (!m_chain_helper.special_tx->CheckSpecialTx(*ptx, m_active_chainstate.m_chain.Tip(),
+                                                   m_active_chainstate.CoinsTip(), /*check_sigs=*/true, state)) {
+        return MempoolAcceptResult::Failure(state);
+    }
+
+    const int64_t vsize = (*held_it)->GetTxSize();
+    const CAmount fee = (*held_it)->GetFee();
+    if (!args.m_test_accept) {
+        m_pool.ReplaceAssetUnlockInstance(ptx);
+        GetMainSignals().TransactionAddedToMempool(ptx, args.m_accept_time, m_pool.GetAndIncrementSequence());
+    }
+    return MempoolAcceptResult::Success(vsize, fee);
+}
+
 MempoolAcceptResult MemPoolAccept::AcceptSingleTransaction(const CTransactionRef& ptx, ATMPArgs& args)
 {
     auto start = Now<SteadyMilliseconds>();
     AssertLockHeld(cs_main);
     LOCK(m_pool.cs); // mempool "read lock" (held through GetMainSignals().TransactionAddedToMempool())
 
+    if (auto refresh_result = TryAssetUnlockRefresh(ptx, args)) return *refresh_result;
+
     Workspace ws(ptx);
 
     if (!PreChecks(args, ws)) return MempoolAcceptResult::Failure(ws.m_state);
@@ -4042,6 +4114,21 @@ static bool CheckMerkleRoot(const CBlock& block, BlockValidationState& state)
             /*debug_message=*/"duplicate transaction");
     }
 
+    // Version 2 asset unlock txids exclude the quorum signing info, so the merkle root above does
+    // not commit to it; the coinbase commits to their instance hashes instead. A mismatch is a
+    // mutation, not block invalidity: a middleman can alter signing-info bytes without breaking
+    // the merkle root, and treating that as invalid would let it poison an honest block's hash.
+    if (!block.vtx.empty() && block.vtx[0]->nType == TRANSACTION_COINBASE) {
+        if (const auto opt_cbTx = GetTxPayload<CCbTx>(*block.vtx[0], /*assert_type=*/false);
+            opt_cbTx && opt_cbTx->nVersion >= CCbTx::Version::MERKLE_ROOT_ASSETUNLOCKS &&
+            opt_cbTx->merkleRootAssetUnlocks != CalcCbTxMerkleRootAssetUnlocks(block)) {
+            return state.Invalid(
+                /*result=*/BlockValidationResult::BLOCK_MUTATED,
+                /*reject_reason=*/"bad-cbtx-assetunlockmerkleroot",
+                /*debug_message=*/"asset unlock instance merkle root mismatch");
+        }
+    }
+
     block.m_checked_merkle_root = true;
     return true;
 }
diff --git a/src/version.h b/src/version.h
index fdc04635d490..d3a38073a652 100644
--- a/src/version.h
+++ b/src/version.h
@@ -11,7 +11,7 @@
  */
 
 
-static const int PROTOCOL_VERSION = 70241;
+static const int PROTOCOL_VERSION = 70242;
 
 //! initial proto version, to be increased after version/verack negotiation
 static const int INIT_PROTO_VERSION = 209;
@@ -72,6 +72,10 @@ static const int PLATFORMBAN_V2_SHORT_ID_VERSION = 70240;
 //! may join rebalance-capable mixing sessions
 static const int COINJOIN_REBALANCE_VERSION = 70241;
 
+//! MSG_ASSET_UNLOCK inventory type added: version 2 asset unlocks are announced by instance hash
+//! so that re-signed instances of one withdrawal (sharing its txid) propagate
+static const int ASSET_UNLOCK_INV_VERSION = 70242;
+
 // Make sure that none of the values above collide with `ADDRV2_FORMAT`.
 
 #endif // BITCOIN_VERSION_H
diff --git a/test/functional/feature_asset_locks.py b/test/functional/feature_asset_locks.py
index ae1821e4e481..204d4087b296 100755
--- a/test/functional/feature_asset_locks.py
+++ b/test/functional/feature_asset_locks.py
@@ -23,10 +23,12 @@
     CTransaction,
     CTxIn,
     CTxOut,
+    MSG_ASSET_UNLOCK,
     tx_from_hex,
     hash256,
     ser_string,
 )
+from test_framework.p2p import P2PInterface
 from test_framework.script import (
     CScript,
     hash160,
@@ -49,10 +51,22 @@
 
 llmq_type_test = 106 # LLMQType::LLMQ_TEST_PLATFORM
 MNEHF_SIGNAL_TX_TYPE = 7 # TRANSACTION_MNHF_SIGNAL
+ASSET_UNLOCK_TX_TYPE = 9 # TRANSACTION_ASSET_UNLOCK
 tiny_amount = int(Decimal("0.0007") * COIN)
 blocks_in_one_day = 100
 HEIGHT_DIFF_EXPIRING = 48
 
+class InvListener(P2PInterface):
+    def __init__(self):
+        super().__init__()
+        self.asset_unlock_invs = []
+
+    def on_inv(self, message):
+        for i in message.inv:
+            if i.type == MSG_ASSET_UNLOCK:
+                self.asset_unlock_invs.append(i.hash)
+
+
 class AssetLocksTest(DashTestFramework):
     def add_options(self, parser):
         self.add_wallet_options(parser)
@@ -106,7 +120,7 @@ def create_assetunlock_request_id(self, index):
         return hash256(request_id_buf)[::-1].hex()
 
 
-    def create_assetunlock(self, index, withdrawal, pubkey=None, fee=tiny_amount):
+    def create_assetunlock(self, index, withdrawal, pubkey=None, fee=tiny_amount, version=1):
         node_wallet = self.nodes[0]
         mninfo = self.mninfo
         assert_greater_than(int(withdrawal), fee)
@@ -119,7 +133,7 @@ def create_assetunlock(self, index, withdrawal, pubkey=None, fee=tiny_amount):
         quorumHash = mninfo[0].get_node(self).quorum("selectquorum", llmq_type_test, request_id)["quorumHash"]
         self.log.info(f"Used quorum hash: {quorumHash}")
         unlockTx_payload = CAssetUnlockTx(
-            version = 1,
+            version = version,
             index = index,
             fee = fee,
             requestedHeight = height,
@@ -143,6 +157,33 @@ def create_assetunlock(self, index, withdrawal, pubkey=None, fee=tiny_amount):
         return unlock_tx
 
 
+    def sync_unlock_instance(self, txid, instance_hash):
+        # A re-signed instance shares the held entry's txid, so sync_mempools() is satisfied
+        # before the refresh has propagated; wait for every node to hold this exact instance.
+        # Refreshes travel as MSG_ASSET_UNLOCK invs on the trickle schedule, which needs time
+        # to advance.
+        def synced():
+            self.bump_mocktime(1)
+            return all(node.getrawtransaction(txid, 1).get('instanceHash') == instance_hash
+                       for node in self.nodes)
+        self.wait_until(synced, timeout=60)
+
+    def get_v2_txid(self, unlock_tx):
+        # The txid of a v2 asset unlock: the tx hashed with the requestedHeight, quorumHash and
+        # quorumSig payload fields zeroed - the fields Platform changes when it re-signs - so
+        # every re-signed instance of one withdrawal shares one txid. The python-side rehash()
+        # of the full serialization is the instance hash instead.
+        payload = CAssetUnlockTx()
+        payload.deserialize(BytesIO(unlock_tx.vExtraPayload))
+        payload.requestedHeight = 0
+        payload.quorumHash = 0
+        payload.quorumSig = b'\x00' * 96
+        tx_copy = copy.deepcopy(unlock_tx)
+        tx_copy.vExtraPayload = payload.serialize()
+        tx_copy.rehash()
+        return tx_copy.hash
+
+
     def create_assetunlock_for_oldest_quorum(self, start_index, withdrawal, pubkey):
         expected_quorum_hash = self.nodes[0].quorum('list')['llmq_test_platform'][-1]
         # Quorum selection depends on the request ID. Scan 100 candidates to
@@ -188,9 +229,9 @@ def check_mempool_size(self):
                    if node.getrawtransaction(txid, 1)['type'] != MNEHF_SIGNAL_TX_TYPE]
             assert_equal(len(own), self.mempool_size)
 
-    def check_mempool_result(self, result_expected, tx):
+    def check_mempool_result(self, result_expected, tx, txid=None):
         """Wrapper to check result of testmempoolaccept on node_0's mempool"""
-        result_expected['txid'] = tx.rehash()
+        result_expected['txid'] = txid or tx.rehash()
         if result_expected['allowed']:
             result_expected['vsize'] = tx.get_vsize()
 
@@ -303,6 +344,7 @@ def run_test(self):
         self.test_withdrawals_fork(node_wallet, node, pubkey)
         self.test_asset_locks_v2_pre_v24(node_wallet, node, pubkey)
         self.test_v24_fork(node_wallet, node, pubkey)
+        self.test_asset_unlock_v2(node_wallet, node, pubkey)
         self.test_non_standard(node_wallet, node, pubkey)
 
 
@@ -807,6 +849,102 @@ def test_asset_unlock_ancestor_package(self, node_wallet, asset_unlock_tx, asset
         assert asset_unlock_txid not in template_txids
         assert child_txid not in template_txids
 
+    def test_asset_unlock_v2(self, node_wallet, node, pubkey):
+        self.log.info("Testing v2 asset unlocks with stable txids...")
+        assert softfork_active(node_wallet, 'v24')
+
+        # The withdrawal window is exhausted by the earlier 3999 DASH unlock, so v2 instances
+        # created here stay unminable in the mempool until the window clears
+        index = 800
+        listener = node_wallet.add_p2p_connection(InvListener())
+        unlock_a = self.create_assetunlock(index, COIN, pubkey, version=2)
+        stable_txid = self.get_v2_txid(unlock_a)
+        instance_a = unlock_a.rehash()
+        assert stable_txid != instance_a
+
+        assert_equal(self.send_tx_simple(unlock_a), stable_txid)
+        self.sync_mempools()
+        rpc_tx = node_wallet.getrawtransaction(stable_txid, 1)
+        assert_equal(rpc_tx['txid'], stable_txid)
+        assert_equal(rpc_tx['instanceHash'], instance_a)
+
+        self.log.info("The v2 unlock is announced by instance hash")
+        self.wait_until(lambda: int(instance_a, 16) in listener.asset_unlock_invs)
+
+        self.log.info("Spend the unmined v2 unlock by its stable txid")
+        child_value = Decimal(unlock_a.vout[0].nValue - tiny_amount) / COIN
+        child_hex = node_wallet.createrawtransaction(
+            [{'txid': stable_txid, 'vout': 0}],
+            {node_wallet.getnewaddress(): child_value})
+        signed_child = node_wallet.signrawtransactionwithwallet(child_hex)
+        assert signed_child['complete']
+        child_txid = node_wallet.sendrawtransaction(signed_child['hex'])
+        self.sync_mempools()
+        assert child_txid in node_wallet.getrawmempool()
+
+        self.log.info("A fresher re-signed instance refreshes the entry in place; same txid, child untouched")
+        self.generate(node, 1)
+        unlock_a2 = self.create_assetunlock(index, COIN, pubkey, version=2)
+        assert_equal(self.get_v2_txid(unlock_a2), stable_txid)
+        instance_a2 = unlock_a2.rehash()
+        assert instance_a2 != instance_a
+        assert_equal(self.send_tx_simple(unlock_a2), stable_txid)
+        self.sync_unlock_instance(stable_txid, instance_a2)
+        mempool = node_wallet.getrawmempool()
+        assert stable_txid in mempool
+        assert child_txid in mempool
+        self.log.info("The refresh is announced under its own instance hash")
+        self.wait_until(lambda: int(instance_a2, 16) in listener.asset_unlock_invs)
+
+        self.log.info("A stale instance does not refresh a fresher one")
+        assert_raises_rpc_error(-26, 'assetunlock-stale-instance', self.send_tx_simple, unlock_a)
+
+        self.log.info("Expire the v2 instance; it and its child must survive in the mempool")
+        self.generate_batch(HEIGHT_DIFF_EXPIRING + 1)
+        mempool = node_wallet.getrawmempool()
+        assert stable_txid in mempool
+        assert child_txid in mempool
+
+        self.log.info("Flush leftover withdrawals from earlier phases and clear the window; the expired instance keeps waiting for a re-sign")
+        # Pending unlocks from the limit tests would otherwise consume the cleared window and
+        # crowd this test's withdrawal out of the block. Mine until each of them is either mined
+        # or expired and evicted; the expired instance under test cannot be mined and stays.
+
+        def other_unlocks_pending():
+            self.sync_mempools()
+            return any(txid != stable_txid and node_wallet.getrawtransaction(txid, 1)['type'] == ASSET_UNLOCK_TX_TYPE
+                       for txid in node_wallet.getrawmempool())
+        flushed = 0
+        while other_unlocks_pending():
+            self.generate(node, 1)
+            flushed += 1
+            assert flushed <= 2 * blocks_in_one_day, "leftover withdrawals never left the mempool"
+        self.generate_batch(101)
+        mempool = node_wallet.getrawmempool()
+        assert stable_txid in mempool
+        assert child_txid in mempool
+
+        self.log.info("Refresh the expired instance with a fresh re-sign and mine it with the child")
+        unlock_b = self.create_assetunlock(index, COIN, pubkey, version=2)
+        assert_equal(self.get_v2_txid(unlock_b), stable_txid)
+        assert_equal(self.send_tx_simple(unlock_b), stable_txid)
+        self.sync_unlock_instance(stable_txid, unlock_b.rehash())
+
+        tip_hash = self.generate(node, 1)[0]
+        block = node_wallet.getblock(tip_hash, 2)
+        mined_txids = [t['txid'] for t in block['tx']]
+        assert stable_txid in mined_txids
+        assert child_txid in mined_txids
+        # The coinbase commits to the mined instance's hash; a single leaf is its own merkle root
+        assert_equal(block['cbTx']['merkleRootAssetUnlocks'], unlock_b.rehash())
+        assert_equal(node_wallet.getassetunlockstatuses([str(index)])[0]['status'], 'mined')
+        child_rpc = node_wallet.getrawtransaction(child_txid, 1)
+        assert_equal(child_rpc['vin'][0]['txid'], stable_txid)
+
+        node_wallet.disconnect_p2ps()
+        self.mempool_size = node_wallet.getmempoolinfo()['size']
+        self.check_mempool_size()
+
     def test_asset_locks_v2_pre_v24(self, node_wallet, node, pubkey):
         self.log.info("Testing asset lock v2 rejection before v24 activation...")
         assert not softfork_active(node_wallet, 'v24')
@@ -820,6 +958,13 @@ def test_asset_locks_v2_pre_v24(self, node_wallet, node, pubkey):
             result_expected={'allowed': False, 'reject-reason': 'bad-assetlocktx-version-2'})
         self.log.info("v2 asset lock correctly rejected pre-v24")
 
+        self.log.info("Testing asset unlock v2 rejection before v24 activation...")
+        unlock_tx_v2 = self.create_assetunlock(590, COIN, pubkey, version=2)
+        # The stable-txid hashing rule applies to any v2 payload, even pre-fork rejected ones
+        self.check_mempool_result(tx=unlock_tx_v2, txid=self.get_v2_txid(unlock_tx_v2),
+            result_expected={'allowed': False, 'reject-reason': 'bad-assetunlocktx-version-2'})
+        self.log.info("v2 asset unlock correctly rejected pre-v24")
+
         self.log.info("Spending RPCs refuse to pay a Platform address before the fork")
         assert_raises_rpc_error(-8, "only valid after v24 activation", node_wallet.sendtoaddress,
                                 encode_platform_p2pkh('tdash', hash160(pubkey)), 1)
diff --git a/test/functional/test_framework/messages.py b/test/functional/test_framework/messages.py
index 1843be6ce083..173a3d830ec2 100755
--- a/test/functional/test_framework/messages.py
+++ b/test/functional/test_framework/messages.py
@@ -61,6 +61,7 @@
 MSG_GOVERNANCE_OBJECT = 17
 MSG_GOVERNANCE_OBJECT_VOTE = 18
 MSG_CMPCT_BLOCK = 20
+MSG_ASSET_UNLOCK = 34
 MSG_TYPE_MASK = 0xffffffff >> 2
 
 FILTER_TYPE_BASIC = 0
@@ -408,6 +409,7 @@ class CInv:
         MSG_GOVERNANCE_OBJECT: "Governance Object",
         MSG_GOVERNANCE_OBJECT_VOTE: "Governance Vote",
         MSG_CMPCT_BLOCK: "CompactBlock",
+        MSG_ASSET_UNLOCK: "Asset Unlock",
     }
 
     def __init__(self, t=0, h=0):
diff --git a/test/functional/test_framework/p2p.py b/test/functional/test_framework/p2p.py
index a76d956a0301..eb669c3237eb 100755
--- a/test/functional/test_framework/p2p.py
+++ b/test/functional/test_framework/p2p.py
@@ -102,9 +102,9 @@
 # The minimum P2P version that this test framework supports
 MIN_P2P_VERSION_SUPPORTED = 60001
 # The P2P version that this test framework implements and sends in its `version` message
-# Version 70241 introduced CoinJoin rebalance (promotion/demotion) sessions and a
-# version-gated flags field in the dsa message
-P2P_VERSION = 70241
+# Version 70242 introduced the MSG_ASSET_UNLOCK inventory type; 70241 introduced CoinJoin
+# rebalance (promotion/demotion) sessions and a version-gated flags field in the dsa message
+P2P_VERSION = 70242
 # The services that this test framework offers in its `version` message
 P2P_SERVICES = NODE_NETWORK | NODE_HEADERS_COMPRESSED
 # The P2P user agent string that this test framework sends in its `version` message
diff --git a/test/lint/lint-circular-dependencies.py b/test/lint/lint-circular-dependencies.py
index 13d3b388c268..a3049bb7e45b 100755
--- a/test/lint/lint-circular-dependencies.py
+++ b/test/lint/lint-circular-dependencies.py
@@ -38,8 +38,11 @@
     "common/bloom -> evo/assetlocktx -> llmq/quorumsman -> llmq/blockprocessor -> net -> common/bloom",
     "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 -> evo/assetlocktx",
     "evo/assetlocktx -> llmq/commitment -> validation -> txmempool -> evo/assetlocktx",
+    "evo/cbtx -> llmq/blockprocessor -> validation -> evo/cbtx",
     "evo/chainhelper -> evo/creditpool -> validation -> evo/chainhelper",
+    "evo/creditpool -> validation -> evo/creditpool",
     "evo/deterministicmns -> node/blockstorage -> validation -> evo/deterministicmns",
     "evo/deterministicmns -> node/blockstorage -> validation -> masternode/payments -> evo/deterministicmns",
     "evo/deterministicmns -> node/blockstorage -> validation -> txmempool -> evo/deterministicmns",