From 8ca5fd9aeced14f6150ee9f76ca70ac9ce77dd53 Mon Sep 17 00:00:00 2001
From: Chris Guida <chrisguida@gmail.com>
Date: Tue, 22 Sep 2026 13:25:20 -0600
Subject: [PATCH 1/6] consensus: Release the long coinbase maturity rule by
 median time past

---
 src/chainparams.cpp                           | 18 ++---
 src/chainparamsbase.cpp                       |  2 +-
 src/consensus/params.h                        | 35 ++++++--
 src/consensus/tx_verify.cpp                   |  8 +-
 src/consensus/tx_verify.h                     |  6 +-
 src/interfaces/chain.h                        |  5 +-
 src/interfaces/node.h                         |  4 +-
 src/kernel/chainparams.cpp                    | 17 ++--
 src/kernel/chainparams.h                      |  4 +-
 src/node/interfaces.cpp                       |  6 +-
 src/qt/transactiondesc.cpp                    |  2 +-
 src/rpc/blockchain.cpp                        | 12 +--
 src/rpc/mining.cpp                            |  2 +-
 src/test/coinbase_maturity_tests.cpp          | 80 ++++++++++++++-----
 src/test/fuzz/coins_view.cpp                  |  3 +-
 .../validation_chainstatemanager_tests.cpp    | 19 +++--
 src/txmempool.cpp                             |  3 +-
 src/validation.cpp                            | 24 +++---
 src/wallet/wallet.cpp                         |  3 +-
 .../feature_chainstate_revalidation.py        |  4 +-
 .../mempool_long_coinbase_maturity.py         | 55 +++++++------
 21 files changed, 195 insertions(+), 117 deletions(-)

diff --git a/src/chainparams.cpp b/src/chainparams.cpp
index e2851d88c986..e9290743e872 100644
--- a/src/chainparams.cpp
+++ b/src/chainparams.cpp
@@ -7,7 +7,6 @@
 
 #include <chainparamsbase.h>
 #include <common/args.h>
-#include <consensus/consensus.h>
 #include <consensus/params.h>
 #include <deploymentinfo.h>
 #include <logging.h>
@@ -104,28 +103,25 @@ void ReadRegTestArgs(const ArgsManager& args, CChainParams::RegTestOptions& opti
     if (const auto arg{args.GetArg("-testcoinbasematuritylong")}; arg) {
         const auto values{SplitString(*arg, ':')};
         if (values.size() != 3) {
-            throw std::runtime_error(strprintf("Invalid format (%s) for -testcoinbasematuritylong=<start_height>:<enforce_height>:<release_height>.", *arg));
+            throw std::runtime_error(strprintf("Invalid format (%s) for -testcoinbasematuritylong=<start_height>:<enforce_height>:<expiry_time>.", *arg));
         }
 
         int32_t start_height;
         int32_t enforce_height;
-        int32_t release_height;
+        int64_t expiry_time;
         if (!ParseInt32(values[0], &start_height) || start_height < 0 || start_height >= std::numeric_limits<int>::max()) {
-            throw std::runtime_error(strprintf("Invalid start height (%s) for -testcoinbasematuritylong=<start_height>:<enforce_height>:<release_height>.", values[0]));
+            throw std::runtime_error(strprintf("Invalid start height (%s) for -testcoinbasematuritylong=<start_height>:<enforce_height>:<expiry_time>.", values[0]));
         }
         if (!ParseInt32(values[1], &enforce_height) || enforce_height < 2 || enforce_height >= std::numeric_limits<int>::max()) {
-            throw std::runtime_error(strprintf("Invalid enforce height (%s) for -testcoinbasematuritylong=<start_height>:<enforce_height>:<release_height>.", values[1]));
+            throw std::runtime_error(strprintf("Invalid enforce height (%s) for -testcoinbasematuritylong=<start_height>:<enforce_height>:<expiry_time>.", values[1]));
         }
-        if (!ParseInt32(values[2], &release_height) || release_height <= start_height || release_height <= enforce_height || release_height >= std::numeric_limits<int>::max()) {
-            throw std::runtime_error(strprintf("Invalid release height (%s) for -testcoinbasematuritylong=<start_height>:<enforce_height>:<release_height>.", values[2]));
-        }
-        if (release_height - start_height <= COINBASE_MATURITY) {
-            throw std::runtime_error(strprintf("Invalid height range (%s) for -testcoinbasematuritylong=<start_height>:<enforce_height>:<release_height>: release_height - start_height must exceed COINBASE_MATURITY.", *arg));
+        if (!ParseInt64(values[2], &expiry_time) || expiry_time <= 0) {
+            throw std::runtime_error(strprintf("Invalid expiry time (%s) for -testcoinbasematuritylong=<start_height>:<enforce_height>:<expiry_time>.", values[2]));
         }
 
         options.coinbase_maturity_long_start_height = start_height;
         options.coinbase_maturity_long_enforce_height = enforce_height;
-        options.coinbase_maturity_long_release_height = release_height;
+        options.coinbase_maturity_long_release_time = expiry_time;
     }
 
     for (const std::string& strDeployment : args.GetArgs("-vbparams")) {
diff --git a/src/chainparamsbase.cpp b/src/chainparamsbase.cpp
index de5a866c7c4f..7043197ea915 100644
--- a/src/chainparamsbase.cpp
+++ b/src/chainparamsbase.cpp
@@ -19,7 +19,7 @@ void SetupChainParamsBaseOptions(ArgsManager& argsman)
     argsman.AddArg("-testactivationheight=name@height.", "Set the activation height of 'name' (segwit, bip34, dersig, cltv, csv, blake2b). (regtest-only)", ArgsManager::ALLOW_ANY | ArgsManager::DEBUG_ONLY, OptionsCategory::DEBUG_TEST);
     argsman.AddArg("-rdtsexpiry=<time>", "Schedule the RDTS expiry: RDTS rules apply to blocks from the blake2b activation height until the parent block's median-time-past reaches <time>. Requires -testactivationheight=blake2b@<height>. (regtest-only)", ArgsManager::ALLOW_ANY | ArgsManager::DEBUG_ONLY, OptionsCategory::DEBUG_TEST);
     argsman.AddArg("-blake2b_headline=<headline>", "Specify consensus-critical proof-of-time news headline. Requires -testactivationheight=blake2b@<height>. (regtest-only)", ArgsManager::ALLOW_ANY | ArgsManager::DEBUG_ONLY, OptionsCategory::DEBUG_TEST);
-    argsman.AddArg("-testcoinbasematuritylong=<start_height>:<enforce_height>:<release_height>", "Set long coinbase maturity parameters. Note that <start_height> must not be changed once used with a chainstate. (regtest-only)", ArgsManager::ALLOW_ANY | ArgsManager::DEBUG_ONLY, OptionsCategory::DEBUG_TEST);
+    argsman.AddArg("-testcoinbasematuritylong=<start_height>:<enforce_height>:<expiry_time>", "Set long coinbase maturity parameters: from block <enforce_height>, generated coins of block <start_height> or later cannot be spent until the parent block's median-time-past reaches <expiry_time>. Note that <start_height> must not be changed once used with a chainstate. (regtest-only)", ArgsManager::ALLOW_ANY | ArgsManager::DEBUG_ONLY, OptionsCategory::DEBUG_TEST);
     argsman.AddArg("-testnet", "Use the testnet3 chain. Equivalent to -chain=test. Support for testnet3 is deprecated and will be removed in an upcoming release. Consider moving to testnet4 now by using -testnet4.", ArgsManager::ALLOW_ANY, OptionsCategory::CHAINPARAMS);
     argsman.AddArg("-testnet4", "Use the testnet4 chain. Equivalent to -chain=testnet4.", ArgsManager::ALLOW_ANY, OptionsCategory::CHAINPARAMS);
     argsman.AddArg("-vbparams=deployment:start:end[:min_activation_height]", "Use given start/end times and min_activation_height for specified version bits deployment (regtest-only)", ArgsManager::ALLOW_ANY | ArgsManager::DEBUG_ONLY, OptionsCategory::CHAINPARAMS);
diff --git a/src/consensus/params.h b/src/consensus/params.h
index 45ef3291eedf..01d10ca96309 100644
--- a/src/consensus/params.h
+++ b/src/consensus/params.h
@@ -6,7 +6,6 @@
 #ifndef BITCOIN_CONSENSUS_PARAMS_H
 #define BITCOIN_CONSENSUS_PARAMS_H
 
-#include <consensus/consensus.h>
 #include <uint256.h>
 
 #include <chrono>
@@ -153,13 +152,39 @@ struct Params {
      * behaviour is unchanged on chains that do not set it.
      */
     int64_t RdtsExpiryTime{std::numeric_limits<int64_t>::min()};
-    int CoinbaseMaturityLong{COINBASE_MATURITY};
+    /**
+     * Long coinbase maturity temporary softfork.
+     *
+     * From CoinbaseMaturityLongEnforceHeight, coinbases of height
+     * CoinbaseMaturityLongStartHeight or later cannot be spent at any depth
+     * until the rule expires. A block is past expiry when its parent's
+     * median-time-past has reached CoinbaseMaturityLongReleaseTime (the same
+     * boundary as RdtsExpiryTime), so the boundary is monotone along any
+     * chain and the rules for the next block are knowable in advance. Every
+     * other coinbase needs COINBASE_MATURITY as always.
+     *
+     * The defaults leave the rule unscheduled.
+     */
     int CoinbaseMaturityLongStartHeight{std::numeric_limits<int>::max()};
     int CoinbaseMaturityLongEnforceHeight{std::numeric_limits<int>::max()};
-    int CoinbaseMaturityLongReleaseHeight{std::numeric_limits<int>::max()};
-    bool CoinbaseMaturityLongActiveAt(int height) const
+    int64_t CoinbaseMaturityLongReleaseTime{std::numeric_limits<int64_t>::min()};
+    bool CoinbaseMaturityLongScheduled() const
+    {
+        return CoinbaseMaturityLongStartHeight != std::numeric_limits<int>::max();
+    }
+    /** Whether the rule applies to a block at the given height whose parent has the given median-time-past. */
+    bool CoinbaseMaturityLongActiveAt(int height, int64_t mtp_prev) const
+    {
+        return height >= CoinbaseMaturityLongEnforceHeight && mtp_prev < CoinbaseMaturityLongReleaseTime;
+    }
+    /**
+     * First coinbase height that cannot be spent in a block at the given
+     * height whose parent has the given median-time-past, or
+     * std::numeric_limits<int>::max() when the rule does not apply to it.
+     */
+    int CoinbaseMaturityLongHeldFrom(int height, int64_t mtp_prev) const
     {
-        return height >= CoinbaseMaturityLongEnforceHeight && height < CoinbaseMaturityLongReleaseHeight;
+        return CoinbaseMaturityLongActiveAt(height, mtp_prev) ? CoinbaseMaturityLongStartHeight : std::numeric_limits<int>::max();
     }
     std::vector<ChainstateRevalidationDeployment> chainstate_revalidation_deployments;
     /** Don't warn about unknown BIP 9 activations below this height.
diff --git a/src/consensus/tx_verify.cpp b/src/consensus/tx_verify.cpp
index 04bce22b6147..b3a2880ddf89 100644
--- a/src/consensus/tx_verify.cpp
+++ b/src/consensus/tx_verify.cpp
@@ -173,7 +173,6 @@ bool Consensus::CheckOutputSizes(const CTransaction& tx, TxValidationState& stat
 }
 
 bool Consensus::CheckTxInputs(const CTransaction& tx, TxValidationState& state, const CCoinsViewCache& inputs, int nSpendHeight, CAmount& txfee, const CheckTxInputsRules rules,
-                              const int coinbase_maturity_long,
                               const int long_maturity_start_height)
 {
     // are the actual inputs available?
@@ -195,9 +194,12 @@ bool Consensus::CheckTxInputs(const CTransaction& tx, TxValidationState& state,
 
         // If prev is coinbase, check that it's matured
         if (coin.IsCoinBase()) {
+            if (coin.nHeight >= static_cast<uint32_t>(long_maturity_start_height)) {
+                return state.Invalid(TxValidationResult::TX_PREMATURE_SPEND, "bad-txns-premature-spend-of-coinbase-long",
+                    strprintf("tried to spend coinbase of block %d, held by the long coinbase maturity rule", coin.nHeight));
+            }
             const int actual_maturity{nSpendHeight - (int)coin.nHeight};
-            const int required_maturity{(coin.nHeight >= long_maturity_start_height) ? coinbase_maturity_long : COINBASE_MATURITY};
-            if (actual_maturity < required_maturity) {
+            if (actual_maturity < COINBASE_MATURITY) {
                 return state.Invalid(TxValidationResult::TX_PREMATURE_SPEND, "bad-txns-premature-spend-of-coinbase",
                     strprintf("tried to spend coinbase at depth %d", actual_maturity));
             }
diff --git a/src/consensus/tx_verify.h b/src/consensus/tx_verify.h
index 07583a1ab44c..79a2b965bf88 100644
--- a/src/consensus/tx_verify.h
+++ b/src/consensus/tx_verify.h
@@ -53,13 +53,11 @@ bool CheckOutputSizes(const CTransaction& tx, TxValidationState& state);
  * Check whether all inputs of this transaction are valid (no double spends and amounts)
  * This does not modify the UTXO set. This does not check scripts and sigs.
  * @param[out] txfee Set to the transaction fee if successful.
- * @param[in] coinbase_maturity_long Maturity required by the long-maturity rule.
- * @param[in] long_maturity_start_height First coinbase height requiring coinbase_maturity_long,
- *                                      or std::numeric_limits<int>::max() to disable.
+ * @param[in] long_maturity_start_height Coinbases of this height or later cannot be spent at any depth
+ *                                       (long coinbase maturity rule), or std::numeric_limits<int>::max() to disable.
  * Preconditions: tx.IsCoinBase() is false.
  */
 [[nodiscard]] bool CheckTxInputs(const CTransaction& tx, TxValidationState& state, const CCoinsViewCache& inputs, int nSpendHeight, CAmount& txfee, CheckTxInputsRules rules,
-                                 int coinbase_maturity_long,
                                  int long_maturity_start_height);
 } // namespace Consensus
 
diff --git a/src/interfaces/chain.h b/src/interfaces/chain.h
index f318d859e1c9..8f8088b330d7 100644
--- a/src/interfaces/chain.h
+++ b/src/interfaces/chain.h
@@ -144,9 +144,8 @@ class Chain
     //! pruned), and contains transactions.
     virtual bool haveBlockOnDisk(int height) = 0;
 
-    //! Number of blocks policy requires a coinbase output to be buried under
-    //! before the wallet should treat it as spendable.
-    virtual int coinbaseMaturity() = 0;
+    //! Whether the long coinbase maturity rule is scheduled on this chain.
+    virtual bool coinbaseMaturityLongScheduled() = 0;
 
     virtual bool pruneLockExists(const std::string& name) const = 0;
     virtual bool updatePruneLock(const std::string& name, const node::PruneLockInfo& lock_info, bool sync=false) = 0;
diff --git a/src/interfaces/node.h b/src/interfaces/node.h
index b73942e8032f..e13e82338202 100644
--- a/src/interfaces/node.h
+++ b/src/interfaces/node.h
@@ -185,8 +185,8 @@ class Node
     //! Get last block time.
     virtual int64_t getLastBlockTime() = 0;
 
-    //! Get coinbase maturity.
-    virtual int coinbaseMaturity() = 0;
+    //! Whether the long coinbase maturity rule is scheduled on this chain.
+    virtual bool coinbaseMaturityLongScheduled() = 0;
 
     //! Get verification progress.
     virtual double getVerificationProgress() = 0;
diff --git a/src/kernel/chainparams.cpp b/src/kernel/chainparams.cpp
index 5c2279555ea7..d1766d1f7142 100644
--- a/src/kernel/chainparams.cpp
+++ b/src/kernel/chainparams.cpp
@@ -79,10 +79,14 @@ static CBlock CreateGenesisBlock(uint32_t nTime, uint32_t nNonce, uint32_t nBits
 
 static void AddLongCoinbaseMaturityRevalidationDeployment(Consensus::Params& consensus)
 {
+    // The rule expires by time, so the last height it applies to depends on
+    // the chain: every block from the enforce height on may need checking.
+    // Blocks keep being marked as checked under this name after the expiry,
+    // so an extension of the rule needs a new deployment name.
     consensus.chainstate_revalidation_deployments.push_back({
         .name = "long_coinbase_maturity",
         .start_height = consensus.CoinbaseMaturityLongEnforceHeight,
-        .stop_height = consensus.CoinbaseMaturityLongReleaseHeight - 1,
+        .stop_height = std::numeric_limits<int>::max(),
     });
 }
 
@@ -140,10 +144,10 @@ class CMainParams : public CChainParams {
         // reaching ACTIVE, and that deployment has been removed.)
         consensus.RdtsExpiryTime = 1819756800; // September 1st, 2027 00:00 UTC
 
+        // Long coinbase maturity: held until RDTS expires
         consensus.CoinbaseMaturityLongStartHeight = 973440;
         consensus.CoinbaseMaturityLongEnforceHeight = 973440;
-        consensus.CoinbaseMaturityLongReleaseHeight = 979920;
-        consensus.CoinbaseMaturityLong = consensus.CoinbaseMaturityLongReleaseHeight - consensus.CoinbaseMaturityLongStartHeight;
+        consensus.CoinbaseMaturityLongReleaseTime = consensus.RdtsExpiryTime;
         AddLongCoinbaseMaturityRevalidationDeployment(consensus);
 
         consensus.nMinimumChainWork = uint256{"00000000000000000000000000000000000000013e00277374c9f9eeadc70200"};
@@ -419,10 +423,10 @@ class CTestNet4Params : public CChainParams {
         consensus.Blake2bHeight = 150308;
         consensus.RdtsExpiryTime = 1791903600; // October 13th, 2026 15:00:00 UTC
 
+        // Long coinbase maturity: held until RDTS expires
         consensus.CoinbaseMaturityLongStartHeight = 151406;
         consensus.CoinbaseMaturityLongEnforceHeight = 151550;
-        consensus.CoinbaseMaturityLongReleaseHeight = 158111;
-        consensus.CoinbaseMaturityLong = consensus.CoinbaseMaturityLongReleaseHeight - consensus.CoinbaseMaturityLongStartHeight;
+        consensus.CoinbaseMaturityLongReleaseTime = consensus.RdtsExpiryTime;
         AddLongCoinbaseMaturityRevalidationDeployment(consensus);
 
         consensus.nMinimumChainWork = uint256{"0000000000000000000000000000000000000000000001d6dce8651b6094e4c1"};
@@ -689,8 +693,7 @@ class CRegTestParams : public CChainParams
         if (opts.coinbase_maturity_long_start_height) {
             consensus.CoinbaseMaturityLongStartHeight = *opts.coinbase_maturity_long_start_height;
             consensus.CoinbaseMaturityLongEnforceHeight = *opts.coinbase_maturity_long_enforce_height;
-            consensus.CoinbaseMaturityLongReleaseHeight = *opts.coinbase_maturity_long_release_height;
-            consensus.CoinbaseMaturityLong = consensus.CoinbaseMaturityLongReleaseHeight - consensus.CoinbaseMaturityLongStartHeight;
+            consensus.CoinbaseMaturityLongReleaseTime = *opts.coinbase_maturity_long_release_time;
             AddLongCoinbaseMaturityRevalidationDeployment(consensus);
         }
 
diff --git a/src/kernel/chainparams.h b/src/kernel/chainparams.h
index 34734a6fb48b..7d26552b713b 100644
--- a/src/kernel/chainparams.h
+++ b/src/kernel/chainparams.h
@@ -171,9 +171,11 @@ class CChainParams
         //! value (see -rdtsexpiry). Requires a blake2b activation height.
         std::optional<int64_t> rdts_expiry_time{};
         std::optional<std::vector<unsigned char>> blake2b_headline{};
+        //! Long coinbase maturity schedule (see -testcoinbasematuritylong):
+        //! all three are set together.
         std::optional<int> coinbase_maturity_long_start_height{};
         std::optional<int> coinbase_maturity_long_enforce_height{};
-        std::optional<int> coinbase_maturity_long_release_height{};
+        std::optional<int64_t> coinbase_maturity_long_release_time{};
     };
 
     static std::unique_ptr<const CChainParams> RegTest(const RegTestOptions& options);
diff --git a/src/node/interfaces.cpp b/src/node/interfaces.cpp
index 14fde63134bc..1ee98a86ebf8 100644
--- a/src/node/interfaces.cpp
+++ b/src/node/interfaces.cpp
@@ -335,7 +335,7 @@ class NodeImpl : public Node
         }
         return chainman().GetParams().GenesisBlock().GetBlockTime(); // Genesis block's time of current network
     }
-    int coinbaseMaturity() override { return chainman().GetConsensus().CoinbaseMaturityLong; }
+    bool coinbaseMaturityLongScheduled() override { return chainman().GetConsensus().CoinbaseMaturityLongScheduled(); }
     double getVerificationProgress() override
     {
         return chainman().GuessVerificationProgress(WITH_LOCK(chainman().GetMutex(), return chainman().ActiveChain().Tip()));
@@ -582,9 +582,9 @@ class ChainImpl : public Chain
         const CBlockIndex* block{chainman().ActiveChain()[height]};
         return block && ((block->nStatus & BLOCK_HAVE_DATA) != 0) && block->nTx > 0;
     }
-    int coinbaseMaturity() override
+    bool coinbaseMaturityLongScheduled() override
     {
-        return chainman().GetConsensus().CoinbaseMaturityLong;
+        return chainman().GetConsensus().CoinbaseMaturityLongScheduled();
     }
     bool pruneLockExists(const std::string& name) const override
     {
diff --git a/src/qt/transactiondesc.cpp b/src/qt/transactiondesc.cpp
index 8c5dc9ea017a..e5d082613b1d 100644
--- a/src/qt/transactiondesc.cpp
+++ b/src/qt/transactiondesc.cpp
@@ -329,7 +329,7 @@ QString TransactionDesc::toHTML(interfaces::Node& node, interfaces::Wallet& wall
 
     if (wtx.is_coinbase)
     {
-        const int numBlocksToMaturity{node.coinbaseMaturity() + 1};
+        const int numBlocksToMaturity{COINBASE_MATURITY + 1};
         strHTML += "<br>" + tr("Generated coins must mature %1 blocks before they can be spent. When you generated this block, it was broadcast to the network to be added to the block chain. If it fails to get into the chain, its state will change to \"not accepted\" and it won't be spendable. This may occasionally happen if another node generates a block within a few seconds of yours.").arg(QString::number(numBlocksToMaturity)) + "<br>";
     }
 
diff --git a/src/rpc/blockchain.cpp b/src/rpc/blockchain.cpp
index 5a8cac6d3a3e..c75f6f3c65e8 100644
--- a/src/rpc/blockchain.cpp
+++ b/src/rpc/blockchain.cpp
@@ -1915,8 +1915,7 @@ const std::vector<RPCResult> RPCHelpForDeployment{
     {RPCResult::Type::STR, "type", "one of \"buried\", \"bip9\", \"flagday\""},
     {RPCResult::Type::NUM, "height", /*optional=*/true, "height of the first block which enforces the rules (only for \"buried\" and \"flagday\" types, or \"bip9\" type with \"active\" status)"},
     {RPCResult::Type::NUM, "height_end", /*optional=*/true, "height of the last block which enforces the rules (only for temporary deployments)"},
-    {RPCResult::Type::NUM, "coinbase_start_height", /*optional=*/true, "height of the first generated coin covered by the long coinbase maturity rule (only for \"long_coinbase_maturity\")"},
-    {RPCResult::Type::NUM, "maturity", /*optional=*/true, "required coinbase maturity depth for covered generated coins (only for \"long_coinbase_maturity\")"},
+    {RPCResult::Type::NUM, "coinbase_start_height", /*optional=*/true, "height of the first generated coin covered by the long coinbase maturity rule: while the rules are enforced, no depth makes covered generated coins spendable (only for \"long_coinbase_maturity\")"},
     {RPCResult::Type::BOOL, "active", "true if the consensus rules are enforced for the next block (policy may enforce related rules independently of this flag)"},
     {RPCResult::Type::NUM_TIME, "expiry_time", /*optional=*/true, "median time past at and after which the rules are no longer enforced (only for \"flagday\" type; a block is past expiry when its parent's median time past has reached this value)"},
     {RPCResult::Type::OBJ, "bip9", /*optional=*/true, "status of bip9 softforks (only for \"bip9\" type)",
@@ -1964,18 +1963,19 @@ void RdtsFlagDayDescPushBack(const CBlockIndex* blockindex, UniValue& softforks,
     softforks.pushKV("reduced_data", std::move(rv));
 }
 
+// Long coinbase maturity: a flag-day deployment expiring, like RDTS, when the
+// parent block's median-time-past reaches its expiry time.
 void LongCoinbaseMaturityDescPushBack(const CBlockIndex* blockindex, UniValue& softforks, const ChainstateManager& chainman)
 {
     const Consensus::Params& params{chainman.GetConsensus()};
-    if (params.CoinbaseMaturityLongReleaseHeight == std::numeric_limits<int>::max()) return;
+    if (!params.CoinbaseMaturityLongScheduled()) return;
 
     UniValue rv(UniValue::VOBJ);
     rv.pushKV("type", "flagday");
     rv.pushKV("height", params.CoinbaseMaturityLongEnforceHeight);
-    rv.pushKV("height_end", params.CoinbaseMaturityLongReleaseHeight - 1);
     rv.pushKV("coinbase_start_height", params.CoinbaseMaturityLongStartHeight);
-    rv.pushKV("maturity", params.CoinbaseMaturityLong);
-    rv.pushKV("active", params.CoinbaseMaturityLongActiveAt(blockindex->nHeight + 1));
+    rv.pushKV("expiry_time", params.CoinbaseMaturityLongReleaseTime);
+    rv.pushKV("active", params.CoinbaseMaturityLongActiveAt(blockindex->nHeight + 1, blockindex->GetMedianTimePast()));
     softforks.pushKV("long_coinbase_maturity", std::move(rv));
 }
 
diff --git a/src/rpc/mining.cpp b/src/rpc/mining.cpp
index c7f28f3ca1bd..de7ede940a58 100644
--- a/src/rpc/mining.cpp
+++ b/src/rpc/mining.cpp
@@ -1082,7 +1082,7 @@ static UniValue TemplateToJSON(const Consensus::Params& consensusParams, const C
     if (rdts_active) {
         aRules.push_back("reduced_data");
     }
-    if (pindexPrev != nullptr && consensusParams.CoinbaseMaturityLongActiveAt(pindexPrev->nHeight + 1)) {
+    if (pindexPrev != nullptr && consensusParams.CoinbaseMaturityLongActiveAt(pindexPrev->nHeight + 1, pindexPrev->GetMedianTimePast())) {
         aRules.push_back("long_coinbase_maturity");
     }
 
diff --git a/src/test/coinbase_maturity_tests.cpp b/src/test/coinbase_maturity_tests.cpp
index 490c3ea8d38a..e51bac24ab42 100644
--- a/src/test/coinbase_maturity_tests.cpp
+++ b/src/test/coinbase_maturity_tests.cpp
@@ -3,65 +3,105 @@
 // file COPYING or http://www.opensource.org/licenses/mit-license.php.
 
 #include <chainparams.h>
-#include <consensus/consensus.h>
 #include <consensus/params.h>
 
 #include <boost/test/unit_test.hpp>
 
+#include <cstdint>
 #include <limits>
 
 BOOST_AUTO_TEST_SUITE(coinbase_maturity_tests)
 
 BOOST_AUTO_TEST_CASE(long_maturity_window_boundaries)
 {
+    constexpr int INT_MAX_{std::numeric_limits<int>::max()};
+    constexpr int64_t INT64_MIN_{std::numeric_limits<int64_t>::min()};
+    constexpr int64_t INT64_MAX_{std::numeric_limits<int64_t>::max()};
+
     Consensus::Params params;
+    BOOST_CHECK(!params.CoinbaseMaturityLongScheduled());
+    for (const int64_t mtp_prev : {INT64_MIN_, int64_t{0}, INT64_MAX_}) {
+        BOOST_CHECK(!params.CoinbaseMaturityLongActiveAt(0, mtp_prev));
+        BOOST_CHECK(!params.CoinbaseMaturityLongActiveAt(INT_MAX_, mtp_prev));
+        BOOST_CHECK_EQUAL(params.CoinbaseMaturityLongHeldFrom(INT_MAX_, mtp_prev), INT_MAX_);
+    }
+
+    params.CoinbaseMaturityLongStartHeight = 100;
     params.CoinbaseMaturityLongEnforceHeight = 200;
-    params.CoinbaseMaturityLongReleaseHeight = 300;
+    params.CoinbaseMaturityLongReleaseTime = 1000;
+    BOOST_CHECK(params.CoinbaseMaturityLongScheduled());
 
-    BOOST_CHECK(!params.CoinbaseMaturityLongActiveAt(199));
-    BOOST_CHECK(params.CoinbaseMaturityLongActiveAt(200));
-    BOOST_CHECK(params.CoinbaseMaturityLongActiveAt(299));
-    BOOST_CHECK(!params.CoinbaseMaturityLongActiveAt(300));
-    BOOST_CHECK(!params.CoinbaseMaturityLongActiveAt(std::numeric_limits<int>::max()));
+    // The rule starts at the enforce height, whatever the time...
+    BOOST_CHECK(!params.CoinbaseMaturityLongActiveAt(199, INT64_MIN_));
+    BOOST_CHECK(!params.CoinbaseMaturityLongActiveAt(199, 0));
+    BOOST_CHECK(params.CoinbaseMaturityLongActiveAt(200, INT64_MIN_));
+    BOOST_CHECK(params.CoinbaseMaturityLongActiveAt(200, 0));
+    BOOST_CHECK(params.CoinbaseMaturityLongActiveAt(200, 999));
+    // ...and only the parent's median-time-past reaching the release time ends it
+    BOOST_CHECK(!params.CoinbaseMaturityLongActiveAt(200, 1000));
+    BOOST_CHECK(params.CoinbaseMaturityLongActiveAt(1000000, 999));
+    BOOST_CHECK(!params.CoinbaseMaturityLongActiveAt(1000000, 1000));
+    BOOST_CHECK(!params.CoinbaseMaturityLongActiveAt(INT_MAX_, 1001));
+    BOOST_CHECK(!params.CoinbaseMaturityLongActiveAt(INT_MAX_, INT64_MAX_));
+
+    // While active, coinbases from the start height on are held
+    BOOST_CHECK_EQUAL(params.CoinbaseMaturityLongHeldFrom(199, 0), INT_MAX_);
+    BOOST_CHECK_EQUAL(params.CoinbaseMaturityLongHeldFrom(200, 999), 100);
+    BOOST_CHECK_EQUAL(params.CoinbaseMaturityLongHeldFrom(1000000, 999), 100);
+    BOOST_CHECK_EQUAL(params.CoinbaseMaturityLongHeldFrom(200, 1000), INT_MAX_);
 }
 
-BOOST_AUTO_TEST_CASE(long_maturity_derived_from_schedule)
+BOOST_AUTO_TEST_CASE(long_maturity_schedules)
 {
+    constexpr int INT_MAX_{std::numeric_limits<int>::max()};
+
     const auto main{CChainParams::Main()};
     const auto testnet4{CChainParams::TestNet4()};
     for (const auto* params : {main.get(), testnet4.get()}) {
         const auto& consensus{params->GetConsensus()};
-        BOOST_CHECK_EQUAL(consensus.CoinbaseMaturityLong, consensus.CoinbaseMaturityLongReleaseHeight - consensus.CoinbaseMaturityLongStartHeight);
-        BOOST_CHECK_GT(consensus.CoinbaseMaturityLong, COINBASE_MATURITY);
+        BOOST_CHECK(consensus.CoinbaseMaturityLongScheduled());
+        BOOST_CHECK_LE(consensus.CoinbaseMaturityLongStartHeight, consensus.CoinbaseMaturityLongEnforceHeight);
+        // Released when RDTS expires, at whatever height that turns out to be
+        BOOST_CHECK_EQUAL(consensus.CoinbaseMaturityLongReleaseTime, consensus.RdtsExpiryTime);
+        BOOST_CHECK_GT(consensus.CoinbaseMaturityLongReleaseTime, 0);
+        BOOST_CHECK(!consensus.CoinbaseMaturityLongActiveAt(consensus.CoinbaseMaturityLongEnforceHeight - 1, 0));
+        BOOST_CHECK(consensus.CoinbaseMaturityLongActiveAt(consensus.CoinbaseMaturityLongEnforceHeight, consensus.RdtsExpiryTime - 1));
+        BOOST_CHECK(consensus.CoinbaseMaturityLongActiveAt(INT_MAX_, consensus.RdtsExpiryTime - 1));
+        BOOST_CHECK(!consensus.CoinbaseMaturityLongActiveAt(consensus.CoinbaseMaturityLongEnforceHeight, consensus.RdtsExpiryTime));
         BOOST_REQUIRE_EQUAL(consensus.chainstate_revalidation_deployments.size(), 1);
         const auto& deployment{consensus.chainstate_revalidation_deployments.front()};
         BOOST_CHECK_EQUAL(deployment.name, "long_coinbase_maturity");
         BOOST_CHECK_EQUAL(deployment.start_height, consensus.CoinbaseMaturityLongEnforceHeight);
-        BOOST_CHECK_EQUAL(deployment.stop_height, consensus.CoinbaseMaturityLongReleaseHeight - 1);
+        BOOST_CHECK_EQUAL(deployment.stop_height, INT_MAX_);
     }
 
     const auto regtest_default{CChainParams::RegTest({})};
     const auto& default_consensus{regtest_default->GetConsensus()};
-    BOOST_CHECK_EQUAL(default_consensus.CoinbaseMaturityLong, COINBASE_MATURITY);
-    BOOST_CHECK(!default_consensus.CoinbaseMaturityLongActiveAt(0));
+    BOOST_CHECK(!default_consensus.CoinbaseMaturityLongScheduled());
+    BOOST_CHECK(!default_consensus.CoinbaseMaturityLongActiveAt(0, 0));
     BOOST_CHECK(default_consensus.chainstate_revalidation_deployments.empty());
 
     CChainParams::RegTestOptions options;
     options.coinbase_maturity_long_start_height = 10;
     options.coinbase_maturity_long_enforce_height = 20;
-    options.coinbase_maturity_long_release_height = 150;
+    options.coinbase_maturity_long_release_time = 5000;
     const auto regtest{CChainParams::RegTest(options)};
     const auto& consensus{regtest->GetConsensus()};
-    BOOST_CHECK_EQUAL(consensus.CoinbaseMaturityLong, 140);
-    BOOST_CHECK(!consensus.CoinbaseMaturityLongActiveAt(19));
-    BOOST_CHECK(consensus.CoinbaseMaturityLongActiveAt(20));
-    BOOST_CHECK(consensus.CoinbaseMaturityLongActiveAt(149));
-    BOOST_CHECK(!consensus.CoinbaseMaturityLongActiveAt(150));
+    BOOST_CHECK(consensus.CoinbaseMaturityLongScheduled());
+    BOOST_CHECK_EQUAL(consensus.CoinbaseMaturityLongStartHeight, 10);
+    BOOST_CHECK_EQUAL(consensus.CoinbaseMaturityLongEnforceHeight, 20);
+    BOOST_CHECK_EQUAL(consensus.CoinbaseMaturityLongReleaseTime, 5000);
+    BOOST_CHECK(!consensus.CoinbaseMaturityLongActiveAt(19, 0));
+    BOOST_CHECK(consensus.CoinbaseMaturityLongActiveAt(20, 4999));
+    BOOST_CHECK(!consensus.CoinbaseMaturityLongActiveAt(20, 5000));
+    BOOST_CHECK(consensus.CoinbaseMaturityLongActiveAt(1000000, 4999));
+    BOOST_CHECK(!consensus.CoinbaseMaturityLongActiveAt(1000000, 5000));
+    BOOST_CHECK_EQUAL(consensus.CoinbaseMaturityLongHeldFrom(20, 4999), 10);
     BOOST_REQUIRE_EQUAL(consensus.chainstate_revalidation_deployments.size(), 1);
     const auto& deployment{consensus.chainstate_revalidation_deployments.front()};
     BOOST_CHECK_EQUAL(deployment.name, "long_coinbase_maturity");
     BOOST_CHECK_EQUAL(deployment.start_height, 20);
-    BOOST_CHECK_EQUAL(deployment.stop_height, 149);
+    BOOST_CHECK_EQUAL(deployment.stop_height, INT_MAX_);
 }
 
 BOOST_AUTO_TEST_SUITE_END()
diff --git a/src/test/fuzz/coins_view.cpp b/src/test/fuzz/coins_view.cpp
index 531fcf6767c3..156c16d60662 100644
--- a/src/test/fuzz/coins_view.cpp
+++ b/src/test/fuzz/coins_view.cpp
@@ -257,8 +257,7 @@ FUZZ_TARGET(coins_view, .init = initialize_coins_view)
                     return;
                 }
                 if (Consensus::CheckTxInputs(transaction, state, coins_view_cache, fuzzed_data_provider.ConsumeIntegralInRange<int>(0, std::numeric_limits<int>::max()), tx_fee_out, CheckTxInputsRules::OutputSizeLimit,
-                                             COINBASE_MATURITY,
-                                             std::numeric_limits<int>::max())) {
+                                             /*long_maturity_start_height=*/std::numeric_limits<int>::max())) {
                     assert(MoneyRange(tx_fee_out));
                 }
             },
diff --git a/src/test/validation_chainstatemanager_tests.cpp b/src/test/validation_chainstatemanager_tests.cpp
index b7cce4a4f0b7..8898638d982f 100644
--- a/src/test/validation_chainstatemanager_tests.cpp
+++ b/src/test/validation_chainstatemanager_tests.cpp
@@ -669,7 +669,7 @@ BOOST_FIXTURE_TEST_CASE(chainstatemanager_snapshot_init, SnapshotTestSetup)
 
 struct SnapshotRevalidationTestSetup : SnapshotTestSetup {
     SnapshotRevalidationTestSetup()
-        : SnapshotTestSetup{{"-testcoinbasematuritylong=1:2:103"}}
+        : SnapshotTestSetup{{"-testcoinbasematuritylong=1:2:4102444800"}}
     {
     }
 };
@@ -684,23 +684,28 @@ BOOST_FIXTURE_TEST_CASE(chainstatemanager_snapshot_revalidation_waits_for_backgr
         return chainman.m_blockman.m_block_tree_db->ReadChainstateRevalidationMarker("long_coinbase_maturity", marker);
     };
 
-    // The deployment ends before the snapshot base, so the active snapshot
-    // chainstate must not claim to have revalidated it. The background
-    // chainstate is responsible for validating pre-snapshot history.
-    BOOST_CHECK(!WITH_LOCK(::cs_main, return has_marker()));
+    // The deployment runs on past the snapshot base, so the active snapshot
+    // chainstate marks only what it validated itself: the blocks above the
+    // base. The background chainstate is responsible for validating
+    // pre-snapshot history, and the marker must not claim it yet.
+    BOOST_REQUIRE(WITH_LOCK(::cs_main, return has_marker()));
+    BOOST_CHECK_EQUAL(marker.start_height, 111);
+    BOOST_CHECK_EQUAL(marker.stop_height, 210);
 
     bilingual_str error;
     BOOST_CHECK(chainman.ActiveChainstate().RewindForChainstateRevalidation(error));
     BOOST_CHECK(error.empty());
     BOOST_CHECK_EQUAL(WITH_LOCK(::cs_main, return chainman.ActiveHeight()), 210);
-    BOOST_CHECK(!WITH_LOCK(::cs_main, return has_marker()));
+    BOOST_REQUIRE(WITH_LOCK(::cs_main, return has_marker()));
+    BOOST_CHECK_EQUAL(marker.start_height, 111);
+    BOOST_CHECK_EQUAL(marker.stop_height, 210);
 
     SnapshotCompletionResult res;
     res = WITH_LOCK(::cs_main, return chainman.MaybeCompleteSnapshotValidation());
     BOOST_CHECK_EQUAL(res, SnapshotCompletionResult::SUCCESS);
     BOOST_REQUIRE(WITH_LOCK(::cs_main, return has_marker()));
     BOOST_CHECK_EQUAL(marker.start_height, 2);
-    BOOST_CHECK_EQUAL(marker.stop_height, 102);
+    BOOST_CHECK_EQUAL(marker.stop_height, 210);
     const uint256 marker_block_hash = WITH_LOCK(::cs_main, return chainman.ActiveChain()[marker.stop_height]->GetBlockHash());
     BOOST_CHECK_EQUAL(marker.block_hash, marker_block_hash);
 }
diff --git a/src/txmempool.cpp b/src/txmempool.cpp
index 6d4f523669ca..3874beb51792 100644
--- a/src/txmempool.cpp
+++ b/src/txmempool.cpp
@@ -880,8 +880,7 @@ void CTxMemPool::check(const CCoinsViewCache& active_coins_tip, int64_t spendhei
         // Skip output size checks (CheckTxInputsRules::None), as these transactions already passed
         // output size limits at mempool acceptance; this check only verifies UTXO consistency
         assert(Consensus::CheckTxInputs(tx, dummy_state, mempoolDuplicate, spendheight, txfee, CheckTxInputsRules::None,
-                                        COINBASE_MATURITY,
-                                        std::numeric_limits<int>::max()));
+                                        /*long_maturity_start_height=*/std::numeric_limits<int>::max()));
         for (const auto& input: tx.vin) mempoolDuplicate.SpendCoin(input.prevout);
         AddCoins(mempoolDuplicate, tx, std::numeric_limits<int>::max());
     }
diff --git a/src/validation.cpp b/src/validation.cpp
index 26661fbee5aa..dd3d66b4f04f 100644
--- a/src/validation.cpp
+++ b/src/validation.cpp
@@ -435,12 +435,18 @@ void Chainstate::MaybeUpdateMempoolForReorg(
         // If the transaction spends any coinbase outputs, it must be mature.
         if (it->GetSpendsCoinbase()) {
             const auto& consensusParams{m_chainman.GetParams().GetConsensus()};
+            const CBlockIndex& tip{*m_chain.Tip()};
+            const auto mempool_spend_height{tip.nHeight + 1};
+            const int long_maturity_start_height{consensusParams.CoinbaseMaturityLongHeldFrom(mempool_spend_height, tip.GetMedianTimePast())};
             for (const CTxIn& txin : tx.vin) {
                 if (m_mempool->exists(GenTxid::Txid(txin.prevout.hash))) continue;
                 const Coin& coin{CoinsTip().AccessCoin(txin.prevout)};
                 assert(!coin.IsSpent());
-                const auto mempool_spend_height{m_chain.Tip()->nHeight + 1};
-                if (coin.IsCoinBase() && mempool_spend_height - coin.nHeight < consensusParams.CoinbaseMaturityLong) {
+                if (!coin.IsCoinBase()) continue;
+                if (coin.nHeight >= static_cast<uint32_t>(long_maturity_start_height)) {
+                    return true;
+                }
+                if (mempool_spend_height - coin.nHeight < COINBASE_MATURITY) {
                     return true;
                 }
             }
@@ -1018,9 +1024,12 @@ bool MemPoolAccept::PreChecks(ATMPArgs& args, Workspace& ws)
     const auto block_height_current = m_active_chainstate.m_chain.Height();
     const auto block_height_next = block_height_current + 1;
     const auto& consensusParams{args.m_chainparams.GetConsensus()};
+    const CBlockIndex& tip{*Assert(m_active_chainstate.m_chain.Tip())};
+    // Spends the long coinbase maturity rule would reject in the next block
+    // are not accepted either, so that the mempool never holds a transaction
+    // that cannot be mined
     if (!Consensus::CheckTxInputs(tx, state, m_view, block_height_next, ws.m_base_fees, CheckTxInputsRules::OutputSizeLimit,
-                                  consensusParams.CoinbaseMaturityLong,
-                                  /*long_maturity_start_height=*/ 0)) {
+                                  consensusParams.CoinbaseMaturityLongHeldFrom(block_height_next, tip.GetMedianTimePast()))) {
         return false; // state filled in by CheckTxInputs
     }
 
@@ -3009,8 +3018,7 @@ bool Chainstate::ConnectBlock(const CBlock& block, BlockValidationState& state,
         }
     }
 
-    const bool long_maturity_consensus_active{consensusParams.CoinbaseMaturityLongActiveAt(pindex->nHeight)};
-    const int long_maturity_start_height{long_maturity_consensus_active ? consensusParams.CoinbaseMaturityLongStartHeight : std::numeric_limits<int>::max()};
+    const int long_maturity_start_height{consensusParams.CoinbaseMaturityLongHeldFrom(pindex->nHeight, Assert(pindex->pprev)->GetMedianTimePast())};
 
     std::vector<int> prevheights;
     CAmount nFees = 0;
@@ -3029,9 +3037,7 @@ bool Chainstate::ConnectBlock(const CBlock& block, BlockValidationState& state,
         {
             CAmount txfee = 0;
             TxValidationState tx_state;
-            if (!Consensus::CheckTxInputs(tx, tx_state, view, pindex->nHeight, txfee, chk_input_rules,
-                                          consensusParams.CoinbaseMaturityLong,
-                                          long_maturity_start_height)) {
+            if (!Consensus::CheckTxInputs(tx, tx_state, view, pindex->nHeight, txfee, chk_input_rules, long_maturity_start_height)) {
                 // Any transaction validation failure in ConnectBlock is a block consensus failure
                 state.Invalid(BlockValidationResult::BLOCK_CONSENSUS,
                               tx_state.GetRejectReason(),
diff --git a/src/wallet/wallet.cpp b/src/wallet/wallet.cpp
index bbf18df86b3d..3c5e5bcfe775 100644
--- a/src/wallet/wallet.cpp
+++ b/src/wallet/wallet.cpp
@@ -3646,8 +3646,7 @@ int CWallet::GetTxBlocksToMaturity(const CWalletTx& wtx) const
     }
     int chain_depth = GetTxDepthInMainChain(wtx);
     assert(chain_depth >= 0); // coinbase tx should not be conflicted
-    const int maturity{HaveChain() ? chain().coinbaseMaturity() : COINBASE_MATURITY};
-    return std::max(0, (maturity + 1) - chain_depth);
+    return std::max(0, (COINBASE_MATURITY + 1) - chain_depth);
 }
 
 bool CWallet::IsTxImmatureCoinBase(const CWalletTx& wtx) const
diff --git a/test/functional/feature_chainstate_revalidation.py b/test/functional/feature_chainstate_revalidation.py
index 858de3d74435..ff69e66de04f 100755
--- a/test/functional/feature_chainstate_revalidation.py
+++ b/test/functional/feature_chainstate_revalidation.py
@@ -16,9 +16,9 @@
 
 LONG_START_HEIGHT = 2
 LONG_ENFORCE_HEIGHT = LONG_START_HEIGHT + COINBASE_MATURITY + 2
-LONG_RELEASE_HEIGHT = LONG_ENFORCE_HEIGHT + 2
+LONG_RELEASE_TIME = 4102444800  # 2100-01-01, never reached
 LONG_ARGS = [
-    f"-testcoinbasematuritylong={LONG_START_HEIGHT}:{LONG_ENFORCE_HEIGHT}:{LONG_RELEASE_HEIGHT}",
+    f"-testcoinbasematuritylong={LONG_START_HEIGHT}:{LONG_ENFORCE_HEIGHT}:{LONG_RELEASE_TIME}",
     "-checkmempool=1",
 ]
 
diff --git a/test/functional/mempool_long_coinbase_maturity.py b/test/functional/mempool_long_coinbase_maturity.py
index d35ac1617529..177afeb0125c 100755
--- a/test/functional/mempool_long_coinbase_maturity.py
+++ b/test/functional/mempool_long_coinbase_maturity.py
@@ -4,6 +4,8 @@
 # file COPYING or http://www.opensource.org/licenses/mit-license.php.
 """Test long coinbase maturity policy and consensus."""
 
+import time
+
 from test_framework.blocktools import (
     COINBASE_MATURITY,
     add_witness_commitment,
@@ -17,17 +19,18 @@
 
 LONG_START_HEIGHT = 2
 LONG_ENFORCE_HEIGHT = LONG_START_HEIGHT + COINBASE_MATURITY + 2
-LONG_RELEASE_HEIGHT = LONG_ENFORCE_HEIGHT + 2
-LONG_MATURITY = LONG_RELEASE_HEIGHT - LONG_START_HEIGHT
 DEPLOYMENT = "long_coinbase_maturity"
+REJECT_REASON = "bad-txns-premature-spend-of-coinbase-long"
 
 
 class LongCoinbaseMaturityTest(BitcoinTestFramework):
     def set_test_params(self):
         self.num_nodes = 1
         self.setup_clean_chain = True
+        self.start_time = int(time.time())
+        self.release_time = self.start_time + 10000
         self.extra_args = [[
-            f"-testcoinbasematuritylong={LONG_START_HEIGHT}:{LONG_ENFORCE_HEIGHT}:{LONG_RELEASE_HEIGHT}",
+            f"-testcoinbasematuritylong={LONG_START_HEIGHT}:{LONG_ENFORCE_HEIGHT}:{self.release_time}",
             "-checkmempool=1",
         ]]
 
@@ -51,10 +54,11 @@ def assert_deployment(self, active):
         deployment = node.getdeploymentinfo()["deployments"][DEPLOYMENT]
         assert_equal(deployment["type"], "flagday")
         assert_equal(deployment["height"], LONG_ENFORCE_HEIGHT)
-        assert_equal(deployment["height_end"], LONG_RELEASE_HEIGHT - 1)
         assert_equal(deployment["coinbase_start_height"], LONG_START_HEIGHT)
-        assert_equal(deployment["maturity"], LONG_MATURITY)
+        assert_equal(deployment["expiry_time"], self.release_time)
         assert_equal(deployment["active"], active)
+        assert "height_end" not in deployment
+        assert "maturity" not in deployment
         assert_equal(DEPLOYMENT in node.getblocktemplate({"rules": ["segwit"]})["rules"], active)
 
     def check_rejected_schedules(self):
@@ -64,8 +68,7 @@ def check_rejected_schedules(self):
             (["-testcoinbasematuritylong=1:2"], "Invalid format"),
             (["-testcoinbasematuritylong=-1:2:3"], "Invalid start height"),
             (["-testcoinbasematuritylong=1:-2:3"], "Invalid enforce height"),
-            (["-testcoinbasematuritylong=2:3:3"], "Invalid release height"),
-            ([f"-testcoinbasematuritylong=2:3:{2 + COINBASE_MATURITY}"], "Invalid height range"),
+            (["-testcoinbasematuritylong=1:2:0"], "Invalid expiry time"),
             (["-testcoinbasematuritylong=99999999999999999999:2:3"], "Invalid start height"),
         ]:
             node.assert_start_raises_init_error(extra_args=args, expected_msg=msg, match=ErrorMatch.PARTIAL_REGEX)
@@ -74,23 +77,18 @@ def check_rejected_schedules(self):
     def run_test(self):
         self.check_rejected_schedules()
         node = self.nodes[0]
+        node.setmocktime(self.start_time)
         wallet = MiniWallet(node)
 
         self.generate(wallet, COINBASE_MATURITY)
         self.assert_deployment(active=False)
 
-        self.log.info("Policy keeps all generation spends out until long maturity")
+        self.log.info("Before enforcement, generation spends are relayed at ordinary maturity")
         coinbase_txid = node.getblock(node.getblockhash(1))["tx"][0]
         coinbase_spend = wallet.create_self_transfer(utxo_to_spend=wallet.get_utxo(txid=coinbase_txid))
+        node.sendrawtransaction(coinbase_spend["hex"])
 
-        assert_raises_rpc_error(
-            -26,
-            "bad-txns-premature-spend-of-coinbase",
-            node.sendrawtransaction,
-            coinbase_spend["hex"],
-        )
-
-        self.log.info("Consensus still accepts pre-window rewards at ordinary maturity")
+        self.log.info("Consensus accepts pre-window rewards at ordinary maturity")
         block = self.create_next_block([coinbase_spend["tx"]])
         assert_equal(node.submitblock(block.serialize().hex()), None)
         assert_equal(node.getblockcount(), LONG_ENFORCE_HEIGHT - 3)
@@ -107,26 +105,33 @@ def run_test(self):
         assert_equal(node.getblockcount(), LONG_ENFORCE_HEIGHT - 1)
         self.assert_deployment(active=True)
 
-        self.log.info("Consensus rejects covered rewards at enforcement and before release")
+        self.log.info("From enforcement, covered rewards are held at any depth until release")
         coinbase_txid = node.getblock(node.getblockhash(4))["tx"][0]
         coinbase_spend = wallet.create_self_transfer(utxo_to_spend=wallet.get_utxo(txid=coinbase_txid))
-
+        assert_raises_rpc_error(-26, REJECT_REASON, node.sendrawtransaction, coinbase_spend["hex"])
         block = self.create_next_block([coinbase_spend["tx"]])
-        assert_equal(node.submitblock(block.serialize().hex()), "bad-txns-premature-spend-of-coinbase")
+        assert_equal(node.submitblock(block.serialize().hex()), REJECT_REASON)
         assert_equal(node.getblockcount(), LONG_ENFORCE_HEIGHT - 1)
 
-        while node.getblockcount() < LONG_RELEASE_HEIGHT - 1:
-            block = self.create_next_block()
-            assert_equal(node.submitblock(block.serialize().hex()), None)
-        assert_equal(node.getblockcount(), LONG_RELEASE_HEIGHT - 1)
-        self.assert_deployment(active=False)
+        node.setmocktime(self.release_time + 100)
+        self.generate(wallet, 5)
+        assert node.getblockheader(node.getbestblockhash())["mediantime"] < self.release_time
+        self.assert_deployment(active=True)
+        assert_raises_rpc_error(-26, REJECT_REASON, node.sendrawtransaction, coinbase_spend["hex"])
+        block = self.create_next_block([coinbase_spend["tx"]])
+        assert_equal(node.submitblock(block.serialize().hex()), REJECT_REASON)
 
-        self.log.info("Consensus accepts covered rewards at the release height")
+        self.log.info("The rule is released once the parent's median time past reaches the release time")
+        release_block = self.generate(wallet, 1)[0]
+        assert node.getblockheader(release_block)["mediantime"] >= self.release_time
+        self.assert_deployment(active=False)
         coinbase_txid = node.getblock(node.getblockhash(LONG_START_HEIGHT))["tx"][0]
         release_spend = wallet.create_self_transfer(utxo_to_spend=wallet.get_utxo(txid=coinbase_txid))
         node.sendrawtransaction(release_spend["hex"])
+        node.sendrawtransaction(coinbase_spend["hex"])
         block = self.create_next_block([release_spend["tx"], coinbase_spend["tx"]])
         assert_equal(node.submitblock(block.serialize().hex()), None)
+        assert_equal(node.getrawmempool(), [])
 
 
 if __name__ == "__main__":

From 01cc9684a12546f964c49267171cdbe306a33586 Mon Sep 17 00:00:00 2001
From: Chris Guida <chrisguida@gmail.com>
Date: Tue, 22 Sep 2026 13:34:41 -0600
Subject: [PATCH 2/6] policy: Require one year of median time past before a
 coinbase may be spent

---
 src/policy/policy.h                           |  4 ++++
 src/validation.cpp                            | 20 ++++++++++++++++
 .../mempool_long_coinbase_maturity.py         | 23 +++++++++++++++----
 3 files changed, 43 insertions(+), 4 deletions(-)

diff --git a/src/policy/policy.h b/src/policy/policy.h
index 954c79f4bd17..14a12fe4a6a0 100644
--- a/src/policy/policy.h
+++ b/src/policy/policy.h
@@ -12,6 +12,7 @@
 #include <script/interpreter.h>
 #include <script/solver.h>
 
+#include <chrono>
 #include <cstdint>
 #include <string>
 #include <unordered_set>
@@ -45,6 +46,9 @@ static constexpr unsigned int MINIMUM_BLOCK_RESERVED_WEIGHT{2000};
 static constexpr unsigned int DEFAULT_BLOCK_MIN_TX_FEE{1000};
 /** The maximum weight for transactions we're willing to relay/mine */
 static constexpr int32_t MAX_STANDARD_TX_WEIGHT{400000};
+/** Median time past a coinbase must have aged for before a spend of it is relayed/mined, while
+ *  the long coinbase maturity rule is scheduled (Consensus::Params::CoinbaseMaturityLongScheduled) */
+static constexpr auto COINBASE_MATURITY_POLICY_TIME{std::chrono::days{365}};
 /** The minimum non-witness size for transactions we're willing to relay/mine: one larger than 64  */
 static constexpr unsigned int MIN_STANDARD_TX_NONWITNESS_SIZE{65};
 /** Maximum number of signature check operations in an IsStandard() P2SH script */
diff --git a/src/validation.cpp b/src/validation.cpp
index dd3d66b4f04f..ad5ebf95abeb 100644
--- a/src/validation.cpp
+++ b/src/validation.cpp
@@ -449,6 +449,10 @@ void Chainstate::MaybeUpdateMempoolForReorg(
                 if (mempool_spend_height - coin.nHeight < COINBASE_MATURITY) {
                     return true;
                 }
+                if (consensusParams.CoinbaseMaturityLongScheduled() &&
+                    Assert(m_chain[static_cast<int>(coin.nHeight)])->GetMedianTimePast() + TicksSeconds(COINBASE_MATURITY_POLICY_TIME) > tip.GetMedianTimePast()) {
+                    return true;
+                }
             }
         }
         // Transaction is still valid and cached LockPoints are updated.
@@ -1033,6 +1037,22 @@ bool MemPoolAccept::PreChecks(ATMPArgs& args, Workspace& ws)
         return false; // state filled in by CheckTxInputs
     }
 
+    // While the long coinbase maturity rule is scheduled, policy holds every
+    // coinbase for COINBASE_MATURITY_POLICY_TIME of median time past: covered
+    // coinbases then stay unspendable for at least that long whatever the
+    // block rate, and each of them is released on its own once its time is up
+    if (consensusParams.CoinbaseMaturityLongScheduled()) {
+        for (const CTxIn& txin : tx.vin) {
+            const Coin& coin{m_view.AccessCoin(txin.prevout)};
+            if (!coin.IsCoinBase()) continue;
+            const CBlockIndex& minting_block{*Assert(m_active_chainstate.m_chain[static_cast<int>(coin.nHeight)])};
+            if (minting_block.GetMedianTimePast() + TicksSeconds(COINBASE_MATURITY_POLICY_TIME) > tip.GetMedianTimePast()) {
+                return state.Invalid(TxValidationResult::TX_PREMATURE_SPEND, "premature-spend-of-coinbase-long",
+                                     strprintf("tried to spend coinbase of block %d less than %d days of median time past old", coin.nHeight, COINBASE_MATURITY_POLICY_TIME.count()));
+            }
+        }
+    }
+
     if (m_pool.m_opts.minrelaymaturity) {
         auto max_coin_height = block_height_next - m_pool.m_opts.minrelaymaturity;
         static_assert(std::is_signed_v<decltype(max_coin_height)>, "Unsigned max_coin_height needs a range check");
diff --git a/test/functional/mempool_long_coinbase_maturity.py b/test/functional/mempool_long_coinbase_maturity.py
index 177afeb0125c..6f116a2c1f2e 100755
--- a/test/functional/mempool_long_coinbase_maturity.py
+++ b/test/functional/mempool_long_coinbase_maturity.py
@@ -19,8 +19,10 @@
 
 LONG_START_HEIGHT = 2
 LONG_ENFORCE_HEIGHT = LONG_START_HEIGHT + COINBASE_MATURITY + 2
+COINBASE_MATURITY_POLICY_TIME = 365 * 24 * 60 * 60
 DEPLOYMENT = "long_coinbase_maturity"
 REJECT_REASON = "bad-txns-premature-spend-of-coinbase-long"
+REJECT_REASON_POLICY = "premature-spend-of-coinbase-long"
 
 
 class LongCoinbaseMaturityTest(BitcoinTestFramework):
@@ -83,10 +85,10 @@ def run_test(self):
         self.generate(wallet, COINBASE_MATURITY)
         self.assert_deployment(active=False)
 
-        self.log.info("Before enforcement, generation spends are relayed at ordinary maturity")
+        self.log.info("Policy holds every generation spend for a year of median time past")
         coinbase_txid = node.getblock(node.getblockhash(1))["tx"][0]
         coinbase_spend = wallet.create_self_transfer(utxo_to_spend=wallet.get_utxo(txid=coinbase_txid))
-        node.sendrawtransaction(coinbase_spend["hex"])
+        assert_raises_rpc_error(-26, REJECT_REASON_POLICY, node.sendrawtransaction, coinbase_spend["hex"])
 
         self.log.info("Consensus accepts pre-window rewards at ordinary maturity")
         block = self.create_next_block([coinbase_spend["tx"]])
@@ -127,10 +129,23 @@ def run_test(self):
         self.assert_deployment(active=False)
         coinbase_txid = node.getblock(node.getblockhash(LONG_START_HEIGHT))["tx"][0]
         release_spend = wallet.create_self_transfer(utxo_to_spend=wallet.get_utxo(txid=coinbase_txid))
-        node.sendrawtransaction(release_spend["hex"])
-        node.sendrawtransaction(coinbase_spend["hex"])
+
+        self.log.info("Policy still holds released rewards until their year is up")
+        assert_raises_rpc_error(-26, REJECT_REASON_POLICY, node.sendrawtransaction, release_spend["hex"])
+        assert_raises_rpc_error(-26, REJECT_REASON_POLICY, node.sendrawtransaction, coinbase_spend["hex"])
         block = self.create_next_block([release_spend["tx"], coinbase_spend["tx"]])
         assert_equal(node.submitblock(block.serialize().hex()), None)
+
+        self.log.info("Policy relays generation spends once they are a year of median time past old")
+        coinbase_txid = node.getblock(node.getblockhash(5))["tx"][0]
+        year_spend = wallet.create_self_transfer(utxo_to_spend=wallet.get_utxo(txid=coinbase_txid))
+        node.setmocktime(self.start_time + COINBASE_MATURITY_POLICY_TIME + 10000)
+        self.generate(wallet, 5)
+        assert_raises_rpc_error(-26, REJECT_REASON_POLICY, node.sendrawtransaction, year_spend["hex"])
+        self.generate(wallet, 1)
+        node.sendrawtransaction(year_spend["hex"])
+        assert_equal(node.getrawmempool(), [year_spend["txid"]])
+        self.generate(wallet, 1)
         assert_equal(node.getrawmempool(), [])
 
 

From c2a94066e35adb83e63ea967153c74f025aa2ed3 Mon Sep 17 00:00:00 2001
From: Chris Guida <chrisguida@gmail.com>
Date: Tue, 22 Sep 2026 13:38:33 -0600
Subject: [PATCH 3/6] wallet: Treat coinbases younger than one year as immature

---
 src/interfaces/wallet.h    |  2 ++
 src/qt/transactiondesc.cpp | 30 +++++++++++++++++++++----
 src/wallet/interfaces.cpp  |  1 +
 src/wallet/transaction.h   |  6 +++++
 src/wallet/wallet.cpp      | 46 +++++++++++++++++++++++++++++++++++++-
 src/wallet/wallet.h        | 12 +++++++++-
 6 files changed, 91 insertions(+), 6 deletions(-)

diff --git a/src/interfaces/wallet.h b/src/interfaces/wallet.h
index 035c7800bf05..6d8f4323d6e6 100644
--- a/src/interfaces/wallet.h
+++ b/src/interfaces/wallet.h
@@ -429,6 +429,8 @@ struct WalletTxStatus
 {
     int block_height;
     int blocks_to_maturity;
+    //! Seconds of median time past the long coinbase maturity policy hold still has to run, 0 if none
+    int64_t maturity_time_left;
     int depth_in_main_chain;
     unsigned int time_received;
     uint32_t lock_time;
diff --git a/src/qt/transactiondesc.cpp b/src/qt/transactiondesc.cpp
index e5d082613b1d..a0ce58f861b7 100644
--- a/src/qt/transactiondesc.cpp
+++ b/src/qt/transactiondesc.cpp
@@ -19,6 +19,8 @@
 #include <validation.h>
 #include <wallet/types.h>
 
+#include <algorithm>
+#include <limits>
 #include <stdint.h>
 #include <string>
 
@@ -29,6 +31,15 @@ using wallet::ISMINE_SPENDABLE;
 using wallet::ISMINE_WATCH_ONLY;
 using wallet::isminetype;
 
+namespace {
+//! Whole days (rounded up) that a median-time-past hold still has to run
+int DaysLeft(int64_t seconds_left)
+{
+    constexpr int64_t SECONDS_PER_DAY{24 * 60 * 60};
+    return static_cast<int>(std::min<int64_t>((seconds_left + SECONDS_PER_DAY - 1) / SECONDS_PER_DAY, std::numeric_limits<int>::max()));
+}
+} // namespace
+
 QString TransactionDesc::FormatTxStatus(const interfaces::WalletTxStatus& status, bool inMempool)
 {
     int depth = status.depth_in_main_chain;
@@ -189,10 +200,17 @@ QString TransactionDesc::toHTML(interfaces::Node& node, interfaces::Wallet& wall
         for (const CTxOut& txout : wtx.tx->vout)
             nUnmatured += wallet.getCredit(txout, ISMINE_ALL);
         strHTML += "<b>" + tr("Credit") + ":</b> ";
-        if (status.is_in_main_chain)
-            strHTML += BitcoinUnits::formatHtmlWithUnit(font_for_money, unit, nUnmatured)+ " (" + tr("matures in %n more block(s)", "", status.blocks_to_maturity) + ")";
-        else
+        if (status.is_in_main_chain) {
+            strHTML += BitcoinUnits::formatHtmlWithUnit(font_for_money, unit, nUnmatured) + " (";
+            if (status.maturity_time_left > 0) {
+                strHTML += tr("matures in about %n day(s)", "", DaysLeft(status.maturity_time_left));
+            } else {
+                strHTML += tr("matures in %n more block(s)", "", status.blocks_to_maturity);
+            }
+            strHTML += ")";
+        } else {
             strHTML += "(" + tr("not accepted") + ")";
+        }
         strHTML += "<br>";
     }
     else if (nNet > 0)
@@ -330,7 +348,11 @@ QString TransactionDesc::toHTML(interfaces::Node& node, interfaces::Wallet& wall
     if (wtx.is_coinbase)
     {
         const int numBlocksToMaturity{COINBASE_MATURITY + 1};
-        strHTML += "<br>" + tr("Generated coins must mature %1 blocks before they can be spent. When you generated this block, it was broadcast to the network to be added to the block chain. If it fails to get into the chain, its state will change to \"not accepted\" and it won't be spendable. This may occasionally happen if another node generates a block within a few seconds of yours.").arg(QString::number(numBlocksToMaturity)) + "<br>";
+        strHTML += "<br>" + tr("Generated coins must mature %1 blocks before they can be spent.").arg(QString::number(numBlocksToMaturity));
+        if (status.maturity_time_left > 0) {
+            strHTML += " " + tr("They must also be at least one year old, so these can be spent in about %n day(s).", "", DaysLeft(status.maturity_time_left));
+        }
+        strHTML += " " + tr("When you generated this block, it was broadcast to the network to be added to the block chain. If it fails to get into the chain, its state will change to \"not accepted\" and it won't be spendable. This may occasionally happen if another node generates a block within a few seconds of yours.") + "<br>";
     }
 
     //
diff --git a/src/wallet/interfaces.cpp b/src/wallet/interfaces.cpp
index 1306df85c866..ebbd9178ca6a 100644
--- a/src/wallet/interfaces.cpp
+++ b/src/wallet/interfaces.cpp
@@ -110,6 +110,7 @@ WalletTxStatus MakeWalletTxStatus(const CWallet& wallet, const CWalletTx& wtx)
         wtx.state<TxStateBlockConflicted>() ? wtx.state<TxStateBlockConflicted>()->conflicting_block_height :
         std::numeric_limits<int>::max();
     result.blocks_to_maturity = wallet.GetTxBlocksToMaturity(wtx);
+    result.maturity_time_left = wallet.GetTxMaturityTimeLeft(wtx);
     result.depth_in_main_chain = wallet.GetTxDepthInMainChain(wtx);
     result.time_received = wtx.nTimeReceived;
     result.lock_time = wtx.tx->nLockTime;
diff --git a/src/wallet/transaction.h b/src/wallet/transaction.h
index 9079f6dd82a6..89a0b5e82dc7 100644
--- a/src/wallet/transaction.h
+++ b/src/wallet/transaction.h
@@ -18,6 +18,7 @@
 #include <bitset>
 #include <cstdint>
 #include <map>
+#include <optional>
 #include <utility>
 #include <variant>
 #include <vector>
@@ -236,6 +237,11 @@ class CWalletTx
     mutable bool m_is_cache_empty{true};
     mutable bool fChangeCached;
     mutable CAmount nChangeCached;
+    /**
+     * Median-time-past of the block this transaction is confirmed in, with
+     * that block's hash; cached by CWallet::GetTxBlocksToMaturity.
+     */
+    mutable std::optional<std::pair<uint256, int64_t>> m_confirmed_block_mtp;
 
     CWalletTx(CTransactionRef tx, const TxState& state) : tx(std::move(tx)), m_state(state)
     {
diff --git a/src/wallet/wallet.cpp b/src/wallet/wallet.cpp
index 3c5e5bcfe775..3258e75e24f8 100644
--- a/src/wallet/wallet.cpp
+++ b/src/wallet/wallet.cpp
@@ -32,6 +32,7 @@
 #include <node/types.h>
 #include <outputtype.h>
 #include <policy/feerate.h>
+#include <policy/policy.h>
 #include <primitives/block.h>
 #include <primitives/transaction.h>
 #include <psbt.h>
@@ -684,6 +685,10 @@ void CWallet::SetLastBlockProcessedInMem(int block_height, uint256 block_hash)
 
     m_last_block_processed = block_hash;
     m_last_block_processed_height = block_height;
+    m_last_block_processed_mtp = 0;
+    if (block_height >= 0 && HaveChain() && chain().coinbaseMaturityLongScheduled()) {
+        chain().findBlock(block_hash, FoundBlock().mtpTime(m_last_block_processed_mtp));
+    }
 }
 
 void CWallet::SetLastBlockProcessed(int block_height, uint256 block_hash)
@@ -3637,6 +3642,33 @@ int CWallet::GetTxDepthInMainChain(const CWalletTx& wtx) const
     }
 }
 
+std::optional<int64_t> CWallet::GetTxLongMaturityTime(const CWalletTx& wtx) const
+{
+    AssertLockHeld(cs_wallet);
+
+    const auto* conf{wtx.state<TxStateConfirmed>()};
+    if (!wtx.IsCoinBase() || !conf || !HaveChain() || !chain().coinbaseMaturityLongScheduled()) {
+        return std::nullopt;
+    }
+    if (!wtx.m_confirmed_block_mtp || wtx.m_confirmed_block_mtp->first != conf->confirmed_block_hash) {
+        int64_t mtp;
+        if (!chain().findBlock(conf->confirmed_block_hash, FoundBlock().mtpTime(mtp))) {
+            return std::nullopt;
+        }
+        wtx.m_confirmed_block_mtp = std::make_pair(conf->confirmed_block_hash, mtp);
+    }
+    return wtx.m_confirmed_block_mtp->second + TicksSeconds(COINBASE_MATURITY_POLICY_TIME);
+}
+
+int64_t CWallet::GetTxMaturityTimeLeft(const CWalletTx& wtx) const
+{
+    AssertLockHeld(cs_wallet);
+
+    const auto mature_time{GetTxLongMaturityTime(wtx)};
+    if (!mature_time) return 0;
+    return std::max<int64_t>(0, *mature_time - m_last_block_processed_mtp);
+}
+
 int CWallet::GetTxBlocksToMaturity(const CWalletTx& wtx) const
 {
     AssertLockHeld(cs_wallet);
@@ -3646,7 +3678,19 @@ int CWallet::GetTxBlocksToMaturity(const CWalletTx& wtx) const
     }
     int chain_depth = GetTxDepthInMainChain(wtx);
     assert(chain_depth >= 0); // coinbase tx should not be conflicted
-    return std::max(0, (COINBASE_MATURITY + 1) - chain_depth);
+    const int blocks_to_maturity{std::max(0, (COINBASE_MATURITY + 1) - chain_depth)};
+
+    // While the long coinbase maturity rule is scheduled, policy also holds
+    // every coinbase for COINBASE_MATURITY_POLICY_TIME of median time past
+    // (see MemPoolAccept::PreChecks), so count the blocks that will take
+    const int64_t time_left{GetTxMaturityTimeLeft(wtx)};
+    if (time_left <= 0) {
+        return blocks_to_maturity;
+    }
+    // An estimate, refreshed as each block is processed
+    const int64_t spacing{Params().GetConsensus().nPowTargetSpacing};
+    const int64_t blocks_to_mature_time{(time_left - 1) / spacing + 1};
+    return std::max<int64_t>(blocks_to_maturity, std::min<int64_t>(blocks_to_mature_time, std::numeric_limits<int>::max()));
 }
 
 bool CWallet::IsTxImmatureCoinBase(const CWalletTx& wtx) const
diff --git a/src/wallet/wallet.h b/src/wallet/wallet.h
index 5f81ad458bb4..22af7261fd9d 100644
--- a/src/wallet/wallet.h
+++ b/src/wallet/wallet.h
@@ -418,6 +418,10 @@ class CWallet final : public WalletStorage, public interfaces::Chain::Notificati
      */
     int m_last_block_processed_height GUARDED_BY(cs_wallet) = -1;
 
+    /** Median-time-past of the last block processed, for GetTxBlocksToMaturity
+     * while the long coinbase maturity rule is scheduled. 0 when unknown. */
+    int64_t m_last_block_processed_mtp GUARDED_BY(cs_wallet) = 0;
+
     /**
      * The following is used to track whether a confirmed transaction is in
      * a block that background validation hasn't checked yet, or above the
@@ -546,9 +550,15 @@ class CWallet final : public WalletStorage, public interfaces::Chain::Notificati
     /**
      * @return number of blocks to maturity for this transaction:
      *  0 : is not a coinbase transaction, or is a mature coinbase transaction
-     * >0 : is a coinbase transaction which matures in this many blocks
+     * >0 : is a coinbase transaction which matures in this many blocks (an
+     *      estimate while the long coinbase maturity policy time is what holds it)
      */
     int GetTxBlocksToMaturity(const CWalletTx& wtx) const EXCLUSIVE_LOCKS_REQUIRED(cs_wallet);
+    /** Median time past at which the long coinbase maturity policy hold on a coinbase ends, if the rule is
+     *  scheduled and the median time past of its block is known */
+    std::optional<int64_t> GetTxLongMaturityTime(const CWalletTx& wtx) const EXCLUSIVE_LOCKS_REQUIRED(cs_wallet);
+    /** Seconds of median time past the long coinbase maturity policy hold on a coinbase still has to run, 0 if none */
+    int64_t GetTxMaturityTimeLeft(const CWalletTx& wtx) const EXCLUSIVE_LOCKS_REQUIRED(cs_wallet);
     bool IsTxImmatureCoinBase(const CWalletTx& wtx) const EXCLUSIVE_LOCKS_REQUIRED(cs_wallet);
 
     //! check whether we support the named feature

From a7bc9dbb2d6346f2093a06605f8a1a974a43e7f2 Mon Sep 17 00:00:00 2001
From: Chris Guida <chrisguida@gmail.com>
Date: Tue, 22 Sep 2026 13:40:26 -0600
Subject: [PATCH 4/6] test: Cover the long coinbase maturity release time

---
 ...ure_long_coinbase_maturity_release_time.py | 252 ++++++++++++++++++
 test/functional/test_runner.py                |   1 +
 2 files changed, 253 insertions(+)
 create mode 100755 test/functional/feature_long_coinbase_maturity_release_time.py

diff --git a/test/functional/feature_long_coinbase_maturity_release_time.py b/test/functional/feature_long_coinbase_maturity_release_time.py
new file mode 100755
index 000000000000..26089ce0fa30
--- /dev/null
+++ b/test/functional/feature_long_coinbase_maturity_release_time.py
@@ -0,0 +1,252 @@
+#!/usr/bin/env python3
+# Copyright (c) 2026 The Bitcoin Knots developers
+# Distributed under the MIT software license, see the accompanying
+# file COPYING or http://www.opensource.org/licenses/mit-license.php.
+"""Test the release of the long coinbase maturity rule by median time past.
+
+node0 has the release time from the start, and a wallet.
+node1 does not enforce the rule (as software that stopped enforcing it
+earlier would), accepts a block that the release time makes invalid, and is
+then restarted with it.
+node2 has an earlier release time, and follows node0's chain given more work.
+"""
+
+import time
+
+from test_framework.blocktools import (
+    COINBASE_MATURITY,
+    add_witness_commitment,
+    create_block,
+    create_coinbase,
+)
+from test_framework.test_node import ErrorMatch
+from test_framework.test_framework import BitcoinTestFramework
+from test_framework.util import assert_equal, assert_raises_rpc_error
+from test_framework.wallet import MiniWallet
+
+LONG_START_HEIGHT = 2
+LONG_ENFORCE_HEIGHT = LONG_START_HEIGHT + COINBASE_MATURITY + 2
+COINBASE_MATURITY_POLICY_TIME = 365 * 24 * 60 * 60
+DEPLOYMENT = "long_coinbase_maturity"
+REJECT_REASON = "bad-txns-premature-spend-of-coinbase-long"
+REJECT_REASON_POLICY = "premature-spend-of-coinbase-long"
+
+
+class LongCoinbaseMaturityReleaseTimeTest(BitcoinTestFramework):
+    def add_options(self, parser):
+        self.add_wallet_options(parser)
+
+    def set_test_params(self):
+        self.num_nodes = 3
+        self.setup_clean_chain = True
+        self.enable_wallet_if_possible()
+        self.start_time = int(time.time())
+        self.early_release_time = self.start_time + 10000
+        self.release_time = self.start_time + COINBASE_MATURITY_POLICY_TIME
+        self.timed_args = [
+            f"-testcoinbasematuritylong={LONG_START_HEIGHT}:{LONG_ENFORCE_HEIGHT}:{self.release_time}",
+            "-checkmempool=1",
+        ]
+        self.early_args = [
+            f"-testcoinbasematuritylong={LONG_START_HEIGHT}:{LONG_ENFORCE_HEIGHT}:{self.early_release_time}",
+            "-checkmempool=1",
+        ]
+        self.extra_args = [self.timed_args, ["-checkmempool=1"], self.early_args]
+
+    def set_time(self, mocktime):
+        for node in self.nodes:
+            node.setmocktime(mocktime)
+
+    def reconnect(self):
+        # Peers that have been silent for a jump of mock time are dropped as
+        # inactive; wait that out and connect them again
+        for a, b in [(0, 1), (1, 2)]:
+            self.disconnect_nodes(a, b)
+        for a, b in [(0, 1), (1, 2)]:
+            self.connect_nodes(a, b)
+
+    def create_next_block(self, node, txs=None):
+        tip = node.getbestblockhash()
+        height = node.getblockcount() + 1
+        block = create_block(
+            int(tip, 16),
+            create_coinbase(height),
+            node.getblockheader(tip)["time"] + 1,
+            height=height,
+            txlist=txs,
+        )
+        add_witness_commitment(block)
+        block.solve()
+        return block
+
+    def assert_deployment(self, node, *, active, release_time):
+        deployment = node.getdeploymentinfo()["deployments"][DEPLOYMENT]
+        assert_equal(deployment["type"], "flagday")
+        assert_equal(deployment["height"], LONG_ENFORCE_HEIGHT)
+        assert_equal(deployment["coinbase_start_height"], LONG_START_HEIGHT)
+        assert_equal(deployment["expiry_time"], release_time)
+        assert_equal(deployment["active"], active)
+        assert "height_end" not in deployment
+        assert "maturity" not in deployment
+        assert_equal(DEPLOYMENT in node.getblocktemplate({"rules": ["segwit"]})["rules"], active)
+
+    def get_chaintip_status(self, node, block_hash):
+        for tip in node.getchaintips():
+            if tip["hash"] == block_hash:
+                return tip["status"]
+        raise AssertionError(f"missing chaintip {block_hash}")
+
+    def coinbase_of(self, node, block_hash):
+        return node.getblock(block_hash)["tx"][0]
+
+    def check_rejected_schedules(self):
+        node = self.nodes[0]
+        self.stop_node(0)
+        for args, msg in [
+            ([f"-testcoinbasematuritylong={LONG_START_HEIGHT}:{LONG_ENFORCE_HEIGHT}"], "Invalid format"),
+            ([f"-testcoinbasematuritylong=-1:{LONG_ENFORCE_HEIGHT}:{self.release_time}"], "Invalid start height"),
+            ([f"-testcoinbasematuritylong={LONG_START_HEIGHT}:1:{self.release_time}"], "Invalid enforce height"),
+            ([f"-testcoinbasematuritylong={LONG_START_HEIGHT}:{LONG_ENFORCE_HEIGHT}:soon"], "Invalid expiry time"),
+        ]:
+            node.assert_start_raises_init_error(extra_args=args, expected_msg=msg, match=ErrorMatch.PARTIAL_REGEX)
+        self.start_node(0, extra_args=self.timed_args)
+        self.connect_nodes(0, 1)
+
+    def run_test(self):
+        self.check_rejected_schedules()
+        node_timed, node_lax, node_early = self.nodes
+        wallet = MiniWallet(node_timed)
+        self.set_time(self.start_time)
+
+        self.log.info("Build a common chain on which the rule is enforced")
+        self.generate(wallet, LONG_ENFORCE_HEIGHT + 1)
+        self.assert_deployment(node_timed, active=True, release_time=self.release_time)
+        assert DEPLOYMENT not in node_lax.getdeploymentinfo()["deployments"]
+        self.assert_deployment(node_early, active=True, release_time=self.early_release_time)
+
+        self.log.info("Only the earlier release time is reached by the first jump of time")
+        self.set_time(self.early_release_time + 100)
+        self.reconnect()
+        late_blocks = self.generate(wallet, 7)
+        assert node_timed.getblockheader(late_blocks[-1])["mediantime"] >= self.early_release_time
+        self.assert_deployment(node_timed, active=True, release_time=self.release_time)
+        self.assert_deployment(node_early, active=False, release_time=self.early_release_time)
+        # Coinbases minted at a median time past past the earlier release
+        # time: their year of policy hold outlasts the later release time
+        late_coinbase_a = self.coinbase_of(node_timed, late_blocks[-2])
+        late_coinbase_b = self.coinbase_of(node_timed, late_blocks[-1])
+        if self.is_wallet_compiled():
+            wallet_block = self.generatetoaddress(node_timed, 1, node_timed.getnewaddress())[0]
+            wallet_coinbase = self.coinbase_of(node_timed, wallet_block)
+            wallet_coinbase_value = node_timed.getblock(wallet_block, 2)["tx"][0]["vout"][0]["value"]
+        common_tip = node_timed.getbestblockhash()
+
+        self.log.info("A block spending a held coinbase before the release time is invalid only with it")
+        self.disconnect_nodes(0, 1)
+        self.disconnect_nodes(1, 2)
+        held_spend = wallet.create_self_transfer(utxo_to_spend=wallet.get_utxo(txid=self.coinbase_of(node_timed, node_timed.getblockhash(LONG_START_HEIGHT))))
+        assert_raises_rpc_error(-26, REJECT_REASON, node_timed.sendrawtransaction, held_spend["hex"])
+        bad_block = self.create_next_block(node_timed, [held_spend["tx"]])
+        assert_equal(node_timed.submitblock(bad_block.serialize().hex()), REJECT_REASON)
+        assert_equal(node_timed.getbestblockhash(), common_tip)
+        for node in (node_lax, node_early):
+            assert_equal(node.submitblock(bad_block.serialize().hex()), None)
+            assert_equal(node.getbestblockhash(), bad_block.hash)
+        self.generate(node_lax, 2, sync_fun=self.no_op)
+        bad_branch_tip = node_lax.getbestblockhash()
+
+        self.log.info("Learning of the release time revalidates the blocks connected from the enforce height on")
+        # Blocks are timestamped in mock time, which a restart forgets
+        restart_args = self.timed_args + [f"-mocktime={self.early_release_time + 100}"]
+        with node_lax.assert_debug_log(expected_msgs=["Chainstate revalidation: rewinding"]):
+            self.restart_node(1, extra_args=restart_args)
+        assert_equal(node_lax.getbestblockhash(), common_tip)
+        assert_equal(self.get_chaintip_status(node_lax, bad_branch_tip), "invalid")
+        assert_equal(node_lax.getrawmempool(), [])
+        self.assert_deployment(node_lax, active=True, release_time=self.release_time)
+
+        self.log.info("...and only once")
+        with node_lax.assert_debug_log(expected_msgs=[], unexpected_msgs=["Chainstate revalidation: rewinding"]):
+            self.restart_node(1, extra_args=restart_args)
+        assert_equal(node_lax.getbestblockhash(), common_tip)
+
+        self.log.info("A node past its own release time follows the chain that respects the later one, given more work")
+        self.generate(wallet, 2, sync_fun=self.no_op)
+        self.connect_nodes(0, 1)
+        self.connect_nodes(1, 2)
+        self.sync_blocks()
+        assert_equal(node_early.getbestblockhash(), node_timed.getbestblockhash())
+        assert_equal(self.get_chaintip_status(node_early, bad_block.hash), "valid-fork")
+
+        self.log.info("Bury the later coinbases under ordinary maturity")
+        self.generate(wallet, COINBASE_MATURITY)
+
+        self.log.info("The rule holds until the parent's median time past reaches the release time, however deep the coinbase is")
+        self.set_time(self.release_time + 100)
+        self.reconnect()
+        self.generate(wallet, 5)
+        self.assert_deployment(node_timed, active=True, release_time=self.release_time)
+        assert_raises_rpc_error(-26, REJECT_REASON, node_timed.sendrawtransaction, held_spend["hex"])
+        # Compact block relay announces a block before validating it, so keep
+        # this one from reaching a node that would accept it
+        self.disconnect_nodes(0, 1)
+        bad_block = self.create_next_block(node_timed, [held_spend["tx"]])
+        assert_equal(node_timed.submitblock(bad_block.serialize().hex()), REJECT_REASON)
+
+        release_block = self.generate(wallet, 1, sync_fun=self.no_op)[0]
+        assert node_timed.getblockheader(release_block)["mediantime"] >= self.release_time
+        self.assert_deployment(node_timed, active=False, release_time=self.release_time)
+
+        self.log.info("Once released, a covered coinbase a year old is relayed again")
+        node_timed.sendrawtransaction(held_spend["hex"])
+        assert_equal(node_timed.getrawmempool(), [held_spend["txid"]])
+
+        self.log.info("A reorg back below the release time holds it again")
+        node_timed.invalidateblock(release_block)
+        assert_equal(node_timed.getrawmempool(), [])
+        self.assert_deployment(node_timed, active=True, release_time=self.release_time)
+        node_timed.reconsiderblock(release_block)
+        assert_equal(node_timed.getbestblockhash(), release_block)
+        self.connect_nodes(0, 1)
+        self.sync_blocks()
+
+        self.log.info("Policy holds a released coinbase until its year is up, while consensus accepts its spend")
+        late_spend_a = wallet.create_self_transfer(utxo_to_spend=wallet.get_utxo(txid=late_coinbase_a))
+        assert_raises_rpc_error(-26, REJECT_REASON_POLICY, node_timed.sendrawtransaction, late_spend_a["hex"])
+        node_timed.sendrawtransaction(held_spend["hex"])
+        block = self.create_next_block(node_timed, [held_spend["tx"], late_spend_a["tx"]])
+        assert_equal(node_timed.submitblock(block.serialize().hex()), None)
+        self.sync_blocks()
+        for node in self.nodes:
+            assert_equal(node.getbestblockhash(), block.hash)
+        if self.is_wallet_compiled():
+            self.log.info("The wallet treats a coinbase as immature until its year is up")
+            assert_equal(node_timed.gettransaction(wallet_coinbase)["details"][0]["category"], "immature")
+            balances = node_timed.getbalances()["mine"]
+            assert_equal(balances["immature"], wallet_coinbase_value)
+            assert_equal(balances["trusted"], 0)
+
+        self.log.info("A year of median time past releases each coinbase on its own")
+        late_spend_b = wallet.create_self_transfer(utxo_to_spend=wallet.get_utxo(txid=late_coinbase_b))
+        self.set_time(self.early_release_time + COINBASE_MATURITY_POLICY_TIME + 1000)
+        self.reconnect()
+        self.generate(wallet, 5)
+        assert_raises_rpc_error(-26, REJECT_REASON_POLICY, node_timed.sendrawtransaction, late_spend_b["hex"])
+        if self.is_wallet_compiled():
+            assert_equal(node_timed.gettransaction(wallet_coinbase)["details"][0]["category"], "immature")
+        self.generate(wallet, 1)
+        node_timed.sendrawtransaction(late_spend_b["hex"])
+        assert_equal(node_timed.getrawmempool(), [late_spend_b["txid"]])
+        if self.is_wallet_compiled():
+            assert_equal(node_timed.gettransaction(wallet_coinbase)["details"][0]["category"], "generate")
+            balances = node_timed.getbalances()["mine"]
+            assert_equal(balances["immature"], 0)
+            assert_equal(balances["trusted"], wallet_coinbase_value)
+        self.generate(wallet, 1)
+        assert_equal(node_timed.getrawmempool(), [])
+        for node in self.nodes:
+            assert_equal(node.getbestblockhash(), node_timed.getbestblockhash())
+
+
+if __name__ == "__main__":
+    LongCoinbaseMaturityReleaseTimeTest(__file__).main()
diff --git a/test/functional/test_runner.py b/test/functional/test_runner.py
index 337d66721045..dcc48c8f6b00 100755
--- a/test/functional/test_runner.py
+++ b/test/functional/test_runner.py
@@ -224,6 +224,7 @@
     'interface_rest.py',
     'feature_chainstate_revalidation.py',
     'mempool_long_coinbase_maturity.py',
+    'feature_long_coinbase_maturity_release_time.py',
     'mempool_spend_coinbase.py',
     'wallet_avoid_mixing_output_types.py --descriptors',
     'mempool_reorg.py',

From bb9d7deb567231f795da9db64741369a42e72f91 Mon Sep 17 00:00:00 2001
From: Chris Guida <chrisguida@gmail.com>
Date: Tue, 22 Sep 2026 13:40:26 -0600
Subject: [PATCH 5/6] doc: Add release notes for the one-year coinbase maturity

---
 doc/release-notes-longmaturity-rdts.md | 14 ++++++++++++++
 1 file changed, 14 insertions(+)
 create mode 100644 doc/release-notes-longmaturity-rdts.md

diff --git a/doc/release-notes-longmaturity-rdts.md b/doc/release-notes-longmaturity-rdts.md
new file mode 100644
index 000000000000..799dc44f2928
--- /dev/null
+++ b/doc/release-notes-longmaturity-rdts.md
@@ -0,0 +1,14 @@
+Long coinbase maturity: one year, expiring with RDTS
+----------------------------------------------------
+
+The temporary softfork that Bitcoin Knots 29.4.2 deployed to hold generated bitcoins for longer is extended: instead of ending at block 979920, it expires together with RDTS. Bitcoins generated by block 973440 or any later block cannot be spent in any block whose parent has a median time past earlier than 2027 September 1st 00:00 UTC. From the first block past that, they are spendable at the original maturity of 100 blocks.
+
+This is a softfork on top of 29.4.2. Up to block 979919 the rules are the same, so nothing changes until then. Block 979920 is the first that 29.4.2 could accept and this version reject (one spending bitcoins generated since block 973440), so miners and nodes need to upgrade before it, expected around the end of October at the current block rate (the date moves with the hashrate).
+
+A 29.4.2 node that upgrades only after block 979920 rechecks the blocks it connected from that height on at its first start: it rewinds to block 979919 and reconnects everything above it. A node coming from 29.4.1 or from another implementation has no record of having checked the long maturity rule at all, so it rewinds to block 973439 instead, as it would when upgrading to 29.4.2. Either way the rewind needs the block and undo data of those blocks, so a pruned node that upgrades late may have to reindex. Upgrading before block 979920 avoids all of this.
+
+Policy and the wallet now apply the same delay to every generated coin, measured in time rather than in blocks: the mempool does not relay a spend of a generated coin until the median time past of the chain tip is at least one year (365 days) past that of the block that generated it, and the wallet counts the coin as immature until then. For bitcoins generated since block 973440 this is never sooner than the consensus expiry, which the mempool also enforces directly, so a wallet holding generated bitcoins can no longer select coins that the network would not accept. The GUI shows how many days such a coin still has to wait; the number of blocks to maturity shown for it elsewhere is an estimate, updated with every block.
+
+A spend held by the consensus rule is rejected as `bad-txns-premature-spend-of-coinbase-long` and one held by the policy delay as `premature-spend-of-coinbase-long`; the original 100-block rule keeps `bad-txns-premature-spend-of-coinbase`.
+
+`getdeploymentinfo` reports the expiry as `expiry_time` for `long_coinbase_maturity`, the same field RDTS uses, and no longer reports `height_end` or `maturity` for it. The regtest option `-testcoinbasematuritylong` now takes `<start_height>:<enforce_height>:<expiry_time>`.

From 6d1b0706a83374750e25227ace2e3c9b2cace347 Mon Sep 17 00:00:00 2001
From: Jason Sopko <jason@sopko.net>
Date: Sat, 10 Oct 2026 17:08:12 -0400
Subject: [PATCH 6/6] policy: Limit the one-year coinbase hold to covered coins

The one-year policy and wallet hold applied to every coinbase, so it
also held coinbases from below CoinbaseMaturityLongStartHeight that
consensus holds only for the original 100 blocks and that 29.4.2 policy
relays by block 979919. On mainnet that is 46,123 unspent outputs worth
11,074.2 BTC from blocks 961640 to 973439 (tip 976563), plus pre-fork
coinbases from the last year. Apply the hold from the start height on in
PreChecks, the reorg filter and the wallet, which the GUI's day count
reads. Older coinbases need only the original maturity of 100 blocks.
29.4.2 policy holds them for 6480 blocks, which they all reach by block
979919, so until then a node with this change relays, and its wallet
spends, the newest of them before 29.4.2 nodes accept them.

mempool_long_coinbase_maturity.py and
feature_long_coinbase_maturity_release_time.py now cover a pre-start
coinbase spend that the mempool accepts and keeps when the tip is
invalidated, and a pre-start coinbase that counts as trusted in the
wallet. Both fail with the code change reverted. On a build without the
GUI, unit tests pass and the functional suite passes apart from
tool_cli_completion.py, which compares against the hand-written
completion file still on its base; this commit touches neither that file
nor any RPC help.
---
 doc/release-notes-longmaturity-rdts.md        |  2 +-
 src/policy/policy.h                           |  3 +-
 src/validation.cpp                            |  9 ++++--
 src/wallet/wallet.cpp                         |  8 +++--
 src/wallet/wallet.h                           |  2 +-
 ...ure_long_coinbase_maturity_release_time.py | 29 ++++++++++++++++---
 .../mempool_long_coinbase_maturity.py         |  9 ++++--
 7 files changed, 47 insertions(+), 15 deletions(-)

diff --git a/doc/release-notes-longmaturity-rdts.md b/doc/release-notes-longmaturity-rdts.md
index 799dc44f2928..423badf4dfde 100644
--- a/doc/release-notes-longmaturity-rdts.md
+++ b/doc/release-notes-longmaturity-rdts.md
@@ -7,7 +7,7 @@ This is a softfork on top of 29.4.2. Up to block 979919 the rules are the same,
 
 A 29.4.2 node that upgrades only after block 979920 rechecks the blocks it connected from that height on at its first start: it rewinds to block 979919 and reconnects everything above it. A node coming from 29.4.1 or from another implementation has no record of having checked the long maturity rule at all, so it rewinds to block 973439 instead, as it would when upgrading to 29.4.2. Either way the rewind needs the block and undo data of those blocks, so a pruned node that upgrades late may have to reindex. Upgrading before block 979920 avoids all of this.
 
-Policy and the wallet now apply the same delay to every generated coin, measured in time rather than in blocks: the mempool does not relay a spend of a generated coin until the median time past of the chain tip is at least one year (365 days) past that of the block that generated it, and the wallet counts the coin as immature until then. For bitcoins generated since block 973440 this is never sooner than the consensus expiry, which the mempool also enforces directly, so a wallet holding generated bitcoins can no longer select coins that the network would not accept. The GUI shows how many days such a coin still has to wait; the number of blocks to maturity shown for it elsewhere is an estimate, updated with every block.
+Policy and the wallet now apply the same delay to every coin generated by block 973440 or later, measured in time rather than in blocks: the mempool does not relay a spend of such a coin until the median time past of the chain tip is at least one year (365 days) past that of the block that generated it, and the wallet counts the coin as immature until then. Coins generated before block 973440 need only the original maturity of 100 blocks; 29.4.2 policy held them for 6480 blocks, which they all reach by block 979919. For the covered coins this is never sooner than the consensus expiry, which the mempool also enforces directly, so a wallet holding them can no longer select one that consensus would still reject. The GUI shows how many days such a coin still has to wait; the number of blocks to maturity shown for it elsewhere is an estimate, updated with every block.
 
 A spend held by the consensus rule is rejected as `bad-txns-premature-spend-of-coinbase-long` and one held by the policy delay as `premature-spend-of-coinbase-long`; the original 100-block rule keeps `bad-txns-premature-spend-of-coinbase`.
 
diff --git a/src/policy/policy.h b/src/policy/policy.h
index 14a12fe4a6a0..46a78e7fca44 100644
--- a/src/policy/policy.h
+++ b/src/policy/policy.h
@@ -47,7 +47,8 @@ static constexpr unsigned int DEFAULT_BLOCK_MIN_TX_FEE{1000};
 /** The maximum weight for transactions we're willing to relay/mine */
 static constexpr int32_t MAX_STANDARD_TX_WEIGHT{400000};
 /** Median time past a coinbase must have aged for before a spend of it is relayed/mined, while
- *  the long coinbase maturity rule is scheduled (Consensus::Params::CoinbaseMaturityLongScheduled) */
+ *  the long coinbase maturity rule is scheduled (Consensus::Params::CoinbaseMaturityLongScheduled),
+ *  for coinbases from Consensus::Params::CoinbaseMaturityLongStartHeight on */
 static constexpr auto COINBASE_MATURITY_POLICY_TIME{std::chrono::days{365}};
 /** The minimum non-witness size for transactions we're willing to relay/mine: one larger than 64  */
 static constexpr unsigned int MIN_STANDARD_TX_NONWITNESS_SIZE{65};
diff --git a/src/validation.cpp b/src/validation.cpp
index ad5ebf95abeb..d160238b9ce2 100644
--- a/src/validation.cpp
+++ b/src/validation.cpp
@@ -450,6 +450,7 @@ void Chainstate::MaybeUpdateMempoolForReorg(
                     return true;
                 }
                 if (consensusParams.CoinbaseMaturityLongScheduled() &&
+                    coin.nHeight >= static_cast<uint32_t>(consensusParams.CoinbaseMaturityLongStartHeight) &&
                     Assert(m_chain[static_cast<int>(coin.nHeight)])->GetMedianTimePast() + TicksSeconds(COINBASE_MATURITY_POLICY_TIME) > tip.GetMedianTimePast()) {
                     return true;
                 }
@@ -1038,13 +1039,15 @@ bool MemPoolAccept::PreChecks(ATMPArgs& args, Workspace& ws)
     }
 
     // While the long coinbase maturity rule is scheduled, policy holds every
-    // coinbase for COINBASE_MATURITY_POLICY_TIME of median time past: covered
-    // coinbases then stay unspendable for at least that long whatever the
-    // block rate, and each of them is released on its own once its time is up
+    // coinbase from its start height on for COINBASE_MATURITY_POLICY_TIME of
+    // median time past: covered coinbases then stay unspendable for at least
+    // that long whatever the block rate, and each of them is released on its
+    // own once its time is up. Older coinbases keep the original maturity.
     if (consensusParams.CoinbaseMaturityLongScheduled()) {
         for (const CTxIn& txin : tx.vin) {
             const Coin& coin{m_view.AccessCoin(txin.prevout)};
             if (!coin.IsCoinBase()) continue;
+            if (coin.nHeight < static_cast<uint32_t>(consensusParams.CoinbaseMaturityLongStartHeight)) continue;
             const CBlockIndex& minting_block{*Assert(m_active_chainstate.m_chain[static_cast<int>(coin.nHeight)])};
             if (minting_block.GetMedianTimePast() + TicksSeconds(COINBASE_MATURITY_POLICY_TIME) > tip.GetMedianTimePast()) {
                 return state.Invalid(TxValidationResult::TX_PREMATURE_SPEND, "premature-spend-of-coinbase-long",
diff --git a/src/wallet/wallet.cpp b/src/wallet/wallet.cpp
index 3258e75e24f8..884710d06f7f 100644
--- a/src/wallet/wallet.cpp
+++ b/src/wallet/wallet.cpp
@@ -3650,6 +3650,9 @@ std::optional<int64_t> CWallet::GetTxLongMaturityTime(const CWalletTx& wtx) cons
     if (!wtx.IsCoinBase() || !conf || !HaveChain() || !chain().coinbaseMaturityLongScheduled()) {
         return std::nullopt;
     }
+    if (conf->confirmed_block_height < Params().GetConsensus().CoinbaseMaturityLongStartHeight) {
+        return std::nullopt;
+    }
     if (!wtx.m_confirmed_block_mtp || wtx.m_confirmed_block_mtp->first != conf->confirmed_block_hash) {
         int64_t mtp;
         if (!chain().findBlock(conf->confirmed_block_hash, FoundBlock().mtpTime(mtp))) {
@@ -3681,8 +3684,9 @@ int CWallet::GetTxBlocksToMaturity(const CWalletTx& wtx) const
     const int blocks_to_maturity{std::max(0, (COINBASE_MATURITY + 1) - chain_depth)};
 
     // While the long coinbase maturity rule is scheduled, policy also holds
-    // every coinbase for COINBASE_MATURITY_POLICY_TIME of median time past
-    // (see MemPoolAccept::PreChecks), so count the blocks that will take
+    // every coinbase from its start height on for COINBASE_MATURITY_POLICY_TIME
+    // of median time past (see MemPoolAccept::PreChecks), so count the blocks
+    // that will take
     const int64_t time_left{GetTxMaturityTimeLeft(wtx)};
     if (time_left <= 0) {
         return blocks_to_maturity;
diff --git a/src/wallet/wallet.h b/src/wallet/wallet.h
index 22af7261fd9d..ded17378593f 100644
--- a/src/wallet/wallet.h
+++ b/src/wallet/wallet.h
@@ -555,7 +555,7 @@ class CWallet final : public WalletStorage, public interfaces::Chain::Notificati
      */
     int GetTxBlocksToMaturity(const CWalletTx& wtx) const EXCLUSIVE_LOCKS_REQUIRED(cs_wallet);
     /** Median time past at which the long coinbase maturity policy hold on a coinbase ends, if the rule is
-     *  scheduled and the median time past of its block is known */
+     *  scheduled, the coinbase is from its start height on and the median time past of its block is known */
     std::optional<int64_t> GetTxLongMaturityTime(const CWalletTx& wtx) const EXCLUSIVE_LOCKS_REQUIRED(cs_wallet);
     /** Seconds of median time past the long coinbase maturity policy hold on a coinbase still has to run, 0 if none */
     int64_t GetTxMaturityTimeLeft(const CWalletTx& wtx) const EXCLUSIVE_LOCKS_REQUIRED(cs_wallet);
diff --git a/test/functional/feature_long_coinbase_maturity_release_time.py b/test/functional/feature_long_coinbase_maturity_release_time.py
index 26089ce0fa30..3b9a8ba25098 100755
--- a/test/functional/feature_long_coinbase_maturity_release_time.py
+++ b/test/functional/feature_long_coinbase_maturity_release_time.py
@@ -24,7 +24,7 @@
 from test_framework.util import assert_equal, assert_raises_rpc_error
 from test_framework.wallet import MiniWallet
 
-LONG_START_HEIGHT = 2
+LONG_START_HEIGHT = 3
 LONG_ENFORCE_HEIGHT = LONG_START_HEIGHT + COINBASE_MATURITY + 2
 COINBASE_MATURITY_POLICY_TIME = 365 * 24 * 60 * 60
 DEPLOYMENT = "long_coinbase_maturity"
@@ -119,11 +119,32 @@ def run_test(self):
         self.set_time(self.start_time)
 
         self.log.info("Build a common chain on which the rule is enforced")
-        self.generate(wallet, LONG_ENFORCE_HEIGHT + 1)
+        self.generate(wallet, 1)
+        if self.is_wallet_compiled():
+            pre_start_block = self.generatetoaddress(node_timed, 1, node_timed.getnewaddress())[0]
+            pre_start_coinbase = self.coinbase_of(node_timed, pre_start_block)
+            pre_start_value = node_timed.getblock(pre_start_block, 2)["tx"][0]["vout"][0]["value"]
+        else:
+            self.generate(wallet, 1)
+        self.generate(wallet, LONG_ENFORCE_HEIGHT - 1)
         self.assert_deployment(node_timed, active=True, release_time=self.release_time)
         assert DEPLOYMENT not in node_lax.getdeploymentinfo()["deployments"]
         self.assert_deployment(node_early, active=True, release_time=self.early_release_time)
 
+        self.log.info("Coinbases from before the start height keep ordinary maturity in policy and the wallet")
+        pre_start_spend = wallet.create_self_transfer(utxo_to_spend=wallet.get_utxo(txid=self.coinbase_of(node_timed, node_timed.getblockhash(1))))
+        node_timed.sendrawtransaction(pre_start_spend["hex"])
+        assert_equal(node_timed.getrawmempool(), [pre_start_spend["txid"]])
+        tip = node_timed.getbestblockhash()
+        node_timed.invalidateblock(tip)
+        assert_equal(node_timed.getrawmempool(), [pre_start_spend["txid"]])
+        node_timed.reconsiderblock(tip)
+        if self.is_wallet_compiled():
+            assert_equal(node_timed.gettransaction(pre_start_coinbase)["details"][0]["category"], "generate")
+            assert_equal(node_timed.getbalances()["mine"]["trusted"], pre_start_value)
+        self.generate(wallet, 1)
+        assert_equal(node_timed.getrawmempool(), [])
+
         self.log.info("Only the earlier release time is reached by the first jump of time")
         self.set_time(self.early_release_time + 100)
         self.reconnect()
@@ -224,7 +245,7 @@ def run_test(self):
             assert_equal(node_timed.gettransaction(wallet_coinbase)["details"][0]["category"], "immature")
             balances = node_timed.getbalances()["mine"]
             assert_equal(balances["immature"], wallet_coinbase_value)
-            assert_equal(balances["trusted"], 0)
+            assert_equal(balances["trusted"], pre_start_value)
 
         self.log.info("A year of median time past releases each coinbase on its own")
         late_spend_b = wallet.create_self_transfer(utxo_to_spend=wallet.get_utxo(txid=late_coinbase_b))
@@ -241,7 +262,7 @@ def run_test(self):
             assert_equal(node_timed.gettransaction(wallet_coinbase)["details"][0]["category"], "generate")
             balances = node_timed.getbalances()["mine"]
             assert_equal(balances["immature"], 0)
-            assert_equal(balances["trusted"], wallet_coinbase_value)
+            assert_equal(balances["trusted"], wallet_coinbase_value + pre_start_value)
         self.generate(wallet, 1)
         assert_equal(node_timed.getrawmempool(), [])
         for node in self.nodes:
diff --git a/test/functional/mempool_long_coinbase_maturity.py b/test/functional/mempool_long_coinbase_maturity.py
index 6f116a2c1f2e..b7b50e871ca5 100755
--- a/test/functional/mempool_long_coinbase_maturity.py
+++ b/test/functional/mempool_long_coinbase_maturity.py
@@ -85,23 +85,26 @@ def run_test(self):
         self.generate(wallet, COINBASE_MATURITY)
         self.assert_deployment(active=False)
 
-        self.log.info("Policy holds every generation spend for a year of median time past")
+        self.log.info("Policy relays spends of pre-window rewards at ordinary maturity")
         coinbase_txid = node.getblock(node.getblockhash(1))["tx"][0]
         coinbase_spend = wallet.create_self_transfer(utxo_to_spend=wallet.get_utxo(txid=coinbase_txid))
-        assert_raises_rpc_error(-26, REJECT_REASON_POLICY, node.sendrawtransaction, coinbase_spend["hex"])
+        node.sendrawtransaction(coinbase_spend["hex"])
+        assert_equal(node.getrawmempool(), [coinbase_spend["txid"]])
 
         self.log.info("Consensus accepts pre-window rewards at ordinary maturity")
         block = self.create_next_block([coinbase_spend["tx"]])
         assert_equal(node.submitblock(block.serialize().hex()), None)
         assert_equal(node.getblockcount(), LONG_ENFORCE_HEIGHT - 3)
+        assert_equal(node.getrawmempool(), [])
 
         block = self.create_next_block()
         assert_equal(node.submitblock(block.serialize().hex()), None)
         assert_equal(node.getblockcount(), LONG_ENFORCE_HEIGHT - 2)
 
-        self.log.info("Consensus still accepts covered rewards before the enforcement block")
+        self.log.info("Policy holds covered rewards for a year of median time past, while consensus still accepts them before the enforcement block")
         coinbase_txid = node.getblock(node.getblockhash(3))["tx"][0]
         coinbase_spend = wallet.create_self_transfer(utxo_to_spend=wallet.get_utxo(txid=coinbase_txid))
+        assert_raises_rpc_error(-26, f"{REJECT_REASON_POLICY}, tried to spend coinbase of block 3 less than 365 days", node.sendrawtransaction, coinbase_spend["hex"])
         block = self.create_next_block([coinbase_spend["tx"]])
         assert_equal(node.submitblock(block.serialize().hex()), None)
         assert_equal(node.getblockcount(), LONG_ENFORCE_HEIGHT - 1)