diff --git a/doc/release-notes-rolling-coinbase-maturity.md b/doc/release-notes-rolling-coinbase-maturity.md
new file mode 100644
index 000000000000..7f5c384cd243
--- /dev/null
+++ b/doc/release-notes-rolling-coinbase-maturity.md
@@ -0,0 +1,34 @@
+Consensus
+---------
+
+- Rolling coinbase maturity (1 year). On mainnet, from block 979920, every
+  generated coin mined at height 973440 or later must be buried 52560 blocks
+  (365 days of 144 blocks) before it can be spent. Each reward counts from its
+  own block, so exactly one reward unlocks per block, the first at 1026000.
+
+  This replaces the shared release of the existing long coinbase maturity
+  window: the rewards it holds (973440 to 979919) are no longer all released
+  together at block 979920. Through block 979919 the rules are unchanged.
+  Rewards mined before 973440 keep ordinary 100-block maturity.
+
+  This rule is separate from RDTS. It is decided by block heights alone and
+  does not depend on `RdtsExpiryTime` or the BLAKE2b fork, so it stays in force
+  whether RDTS is extended or lapses.
+
+  Coverage ends with issuance: rewards mined at height 6930000 (the first
+  zero-subsidy height, 33 halvings) or later keep the maturity the other rules
+  require. The end is set by the height a reward was mined at, not the height
+  it is spent at, so every covered reward still waits its full 52560 blocks and
+  nothing is released early. The last covered reward, mined at 6929999,
+  unlocks at 6982559.
+
+  Upgrading nodes check every block from 979920 again using the existing
+  chainstate revalidation, under the marker `rolling_coinbase_maturity_1y`.
+  A node that upgrades before block 979920 rewinds nothing. A pruned node that
+  upgrades later and no longer has those blocks must reindex.
+
+  `getdeploymentinfo` reports the rule as `rolling_coinbase_maturity`, and
+  `getblocktemplate` lists `rolling_coinbase_maturity` in `rules` once it is
+  active. Wallets and the GUI show the maturity that applies to each reward.
+  Testnet4, signet and regtest are unchanged; regtest can opt in with
+  `-testcoinbasematurityrolling=<start_height>:<enforce_height>:<maturity>[:<end_coin_height>]`.
diff --git a/src/chainparams.cpp b/src/chainparams.cpp
index e2851d88c986..aa8f9835746d 100644
--- a/src/chainparams.cpp
+++ b/src/chainparams.cpp
@@ -128,6 +128,37 @@ void ReadRegTestArgs(const ArgsManager& args, CChainParams::RegTestOptions& opti
         options.coinbase_maturity_long_release_height = release_height;
     }
 
+    if (const auto arg{args.GetArg("-testcoinbasematurityrolling")}; arg) {
+        const auto values{SplitString(*arg, ':')};
+        if (values.size() != 3 && values.size() != 4) {
+            throw std::runtime_error(strprintf("Invalid format (%s) for -testcoinbasematurityrolling=<start_height>:<enforce_height>:<maturity>[:<end_coin_height>].", *arg));
+        }
+
+        int32_t start_height;
+        int32_t enforce_height;
+        int32_t maturity;
+        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 -testcoinbasematurityrolling=<start_height>:<enforce_height>:<maturity>[:<end_coin_height>].", 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 -testcoinbasematurityrolling=<start_height>:<enforce_height>:<maturity>[:<end_coin_height>].", values[1]));
+        }
+        if (!ParseInt32(values[2], &maturity) || maturity <= COINBASE_MATURITY || maturity >= std::numeric_limits<int>::max()) {
+            throw std::runtime_error(strprintf("Invalid maturity (%s) for -testcoinbasematurityrolling=<start_height>:<enforce_height>:<maturity>[:<end_coin_height>]: must exceed COINBASE_MATURITY.", values[2]));
+        }
+        if (values.size() == 4) {
+            int32_t end_coin_height;
+            if (!ParseInt32(values[3], &end_coin_height) || end_coin_height <= start_height || end_coin_height >= std::numeric_limits<int>::max()) {
+                throw std::runtime_error(strprintf("Invalid end coin height (%s) for -testcoinbasematurityrolling=<start_height>:<enforce_height>:<maturity>[:<end_coin_height>]: must exceed start_height.", values[3]));
+            }
+            options.coinbase_maturity_rolling_end = end_coin_height;
+        }
+
+        options.coinbase_maturity_rolling_start_height = start_height;
+        options.coinbase_maturity_rolling_enforce_height = enforce_height;
+        options.coinbase_maturity_rolling = maturity;
+    }
+
     for (const std::string& strDeployment : args.GetArgs("-vbparams")) {
         std::vector<std::string> vDeploymentParams = SplitString(strDeployment, ':');
         if (vDeploymentParams.size() < 3 || 7 < vDeploymentParams.size()) {
diff --git a/src/chainparamsbase.cpp b/src/chainparamsbase.cpp
index de5a866c7c4f..1993e222089a 100644
--- a/src/chainparamsbase.cpp
+++ b/src/chainparamsbase.cpp
@@ -19,6 +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("-testcoinbasematurityrolling=<start_height>:<enforce_height>:<maturity>[:<end_coin_height>]", "Set rolling coinbase maturity parameters: from <enforce_height> on, generated coins mined at or above <start_height> (and, if given, below <end_coin_height>) need <maturity> blocks. 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>:<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("-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);
diff --git a/src/consensus/params.h b/src/consensus/params.h
index 45ef3291eedf..15f74ce64b02 100644
--- a/src/consensus/params.h
+++ b/src/consensus/params.h
@@ -9,6 +9,7 @@
 #include <consensus/consensus.h>
 #include <uint256.h>
 
+#include <algorithm>
 #include <chrono>
 #include <limits>
 #include <map>
@@ -161,6 +162,48 @@ struct Params {
     {
         return height >= CoinbaseMaturityLongEnforceHeight && height < CoinbaseMaturityLongReleaseHeight;
     }
+    /**
+     * Rolling coinbase maturity.
+     *
+     * From CoinbaseMaturityRollingEnforceHeight on, every generated coin mined
+     * at or above CoinbaseMaturityRollingStartHeight must be
+     * CoinbaseMaturityRolling blocks deep before it can be spent. Each coin is
+     * measured from its own block, so rewards unlock one per block rather than
+     * together at a shared release height.
+     *
+     * This is independent of RDTS: it is height-based, has no expiry and does
+     * not depend on RdtsExpiryTime. It only ever adds to the maturity required
+     * by the rules above, never reduces it. Unscheduled by default.
+     *
+     * Coins mined at or above CoinbaseMaturityRollingEndCoinHeight are not
+     * covered: they keep the maturity required by the rules above. This bounds
+     * the coverage (e.g. at the first zero-subsidy height, where there is no
+     * subsidy left to protect) without ever releasing a covered coin early.
+     */
+    int CoinbaseMaturityRolling{COINBASE_MATURITY};
+    int CoinbaseMaturityRollingStartHeight{std::numeric_limits<int>::max()};
+    int CoinbaseMaturityRollingEnforceHeight{std::numeric_limits<int>::max()};
+    int CoinbaseMaturityRollingEndCoinHeight{std::numeric_limits<int>::max()};
+    bool CoinbaseMaturityRollingActiveAt(int height) const
+    {
+        return height >= CoinbaseMaturityRollingEnforceHeight;
+    }
+    /**
+     * Consensus maturity a block at spend_height requires of a generated coin
+     * mined at coin_height, under all coinbase maturity rules. Validation
+     * passes the same values to Consensus::CheckTxInputs.
+     */
+    int CoinbaseMaturityRequired(int coin_height, int spend_height) const
+    {
+        int maturity{COINBASE_MATURITY};
+        if (CoinbaseMaturityLongActiveAt(spend_height) && coin_height >= CoinbaseMaturityLongStartHeight) {
+            maturity = CoinbaseMaturityLong;
+        }
+        if (CoinbaseMaturityRollingActiveAt(spend_height) && coin_height >= CoinbaseMaturityRollingStartHeight && coin_height < CoinbaseMaturityRollingEndCoinHeight) {
+            maturity = std::max(maturity, CoinbaseMaturityRolling);
+        }
+        return maturity;
+    }
     std::vector<ChainstateRevalidationDeployment> chainstate_revalidation_deployments;
     /** Don't warn about unknown BIP 9 activations below this height.
      * This prevents us from warning about the CSV and segwit activations. */
diff --git a/src/consensus/tx_verify.cpp b/src/consensus/tx_verify.cpp
index 04bce22b6147..62d6f68ccfac 100644
--- a/src/consensus/tx_verify.cpp
+++ b/src/consensus/tx_verify.cpp
@@ -14,6 +14,8 @@
 #include <util/check.h>
 #include <util/moneystr.h>
 
+#include <algorithm>
+
 bool IsFinalTx(const CTransaction &tx, int nBlockHeight, int64_t nBlockTime)
 {
     if (tx.nLockTime == 0)
@@ -174,7 +176,10 @@ 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)
+                              const int long_maturity_start_height,
+                              const int coinbase_maturity_rolling,
+                              const int rolling_maturity_start_height,
+                              const int rolling_maturity_end_coin_height)
 {
     // are the actual inputs available?
     if (!inputs.HaveInputs(tx)) {
@@ -196,7 +201,10 @@ bool Consensus::CheckTxInputs(const CTransaction& tx, TxValidationState& state,
         // If prev is coinbase, check that it's matured
         if (coin.IsCoinBase()) {
             const int actual_maturity{nSpendHeight - (int)coin.nHeight};
-            const int required_maturity{(coin.nHeight >= long_maturity_start_height) ? coinbase_maturity_long : COINBASE_MATURITY};
+            int required_maturity{(coin.nHeight >= long_maturity_start_height) ? coinbase_maturity_long : COINBASE_MATURITY};
+            if ((int)coin.nHeight >= rolling_maturity_start_height && (int)coin.nHeight < rolling_maturity_end_coin_height) {
+                required_maturity = std::max(required_maturity, coinbase_maturity_rolling);
+            }
             if (actual_maturity < required_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..57094e4f6db9 100644
--- a/src/consensus/tx_verify.h
+++ b/src/consensus/tx_verify.h
@@ -6,7 +6,9 @@
 #define BITCOIN_CONSENSUS_TX_VERIFY_H
 
 #include <consensus/amount.h>
+#include <consensus/consensus.h>
 
+#include <limits>
 #include <stdint.h>
 #include <vector>
 
@@ -56,11 +58,21 @@ bool CheckOutputSizes(const CTransaction& tx, TxValidationState& state);
  * @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] coinbase_maturity_rolling Maturity required by the rolling-maturity rule. It is
+ *                                      only ever applied as a minimum on top of the rules above.
+ * @param[in] rolling_maturity_start_height First coinbase height requiring coinbase_maturity_rolling,
+ *                                         or std::numeric_limits<int>::max() to disable.
+ * @param[in] rolling_maturity_end_coin_height First coinbase height no longer requiring
+ *                                             coinbase_maturity_rolling, or
+ *                                             std::numeric_limits<int>::max() for no end.
  * 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);
+                                 int long_maturity_start_height,
+                                 int coinbase_maturity_rolling = COINBASE_MATURITY,
+                                 int rolling_maturity_start_height = std::numeric_limits<int>::max(),
+                                 int rolling_maturity_end_coin_height = std::numeric_limits<int>::max());
 } // namespace Consensus
 
 /** Auxiliary functions for transaction validation (ideally should not be exposed) */
diff --git a/src/interfaces/chain.h b/src/interfaces/chain.h
index f318d859e1c9..a2d121f8f771 100644
--- a/src/interfaces/chain.h
+++ b/src/interfaces/chain.h
@@ -144,9 +144,10 @@ 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;
+    //! Number of blocks policy requires a coinbase output mined at
+    //! coin_height to be buried under before the wallet should treat it as
+    //! spendable.
+    virtual int coinbaseMaturity(int coin_height) = 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..11031b450215 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;
+    //! Get coinbase maturity for a generated coin mined at coin_height.
+    virtual int coinbaseMaturity(int coin_height) = 0;
 
     //! Get verification progress.
     virtual double getVerificationProgress() = 0;
diff --git a/src/kernel/chainparams.cpp b/src/kernel/chainparams.cpp
index 5c2279555ea7..560500f52170 100644
--- a/src/kernel/chainparams.cpp
+++ b/src/kernel/chainparams.cpp
@@ -86,6 +86,17 @@ static void AddLongCoinbaseMaturityRevalidationDeployment(Consensus::Params& con
     });
 }
 
+static void AddRollingCoinbaseMaturityRevalidationDeployment(Consensus::Params& consensus)
+{
+    // No stop height: the rule never expires, so every block from the
+    // enforcement height on is checked again by an upgrading node. Blocks
+    // before it are unchanged, so a node upgrading earlier rewinds nothing.
+    consensus.chainstate_revalidation_deployments.push_back({
+        .name = "rolling_coinbase_maturity_1y",
+        .start_height = consensus.CoinbaseMaturityRollingEnforceHeight,
+    });
+}
+
 /**
  * Main network on which people trade goods and services.
  */
@@ -146,6 +157,19 @@ class CMainParams : public CChainParams {
         consensus.CoinbaseMaturityLong = consensus.CoinbaseMaturityLongReleaseHeight - consensus.CoinbaseMaturityLongStartHeight;
         AddLongCoinbaseMaturityRevalidationDeployment(consensus);
 
+        // Rolling coinbase maturity: every reward from the start of the long
+        // maturity window above matures over 52560 blocks (365 days of 144
+        // blocks) from its own block, with no expiry. It takes over at the
+        // window's release height, so the rewards the window holds are never
+        // released together there: one reward unlocks per block, the first at
+        // 1026000. Through 979919 the rules are unchanged.
+        consensus.CoinbaseMaturityRollingStartHeight = consensus.CoinbaseMaturityLongStartHeight;
+        consensus.CoinbaseMaturityRollingEnforceHeight = consensus.CoinbaseMaturityLongReleaseHeight;
+        consensus.CoinbaseMaturityRolling = 52560;
+        // first zero-subsidy height (33 halvings), so the rule retires together with issuance
+        consensus.CoinbaseMaturityRollingEndCoinHeight = 6930000;
+        AddRollingCoinbaseMaturityRevalidationDeployment(consensus);
+
         consensus.nMinimumChainWork = uint256{"00000000000000000000000000000000000000013e00277374c9f9eeadc70200"};
         consensus.defaultAssumeValid = uint256{"0000000000000078ed1e20cac1acf78df6d1060c78059fb6331e17141c881fc8"}; // 964264
 
@@ -694,6 +718,16 @@ class CRegTestParams : public CChainParams
             AddLongCoinbaseMaturityRevalidationDeployment(consensus);
         }
 
+        if (opts.coinbase_maturity_rolling_start_height) {
+            consensus.CoinbaseMaturityRollingStartHeight = *opts.coinbase_maturity_rolling_start_height;
+            consensus.CoinbaseMaturityRollingEnforceHeight = *opts.coinbase_maturity_rolling_enforce_height;
+            consensus.CoinbaseMaturityRolling = *opts.coinbase_maturity_rolling;
+            if (opts.coinbase_maturity_rolling_end) {
+                consensus.CoinbaseMaturityRollingEndCoinHeight = *opts.coinbase_maturity_rolling_end;
+            }
+            AddRollingCoinbaseMaturityRevalidationDeployment(consensus);
+        }
+
         for (const auto& [deployment_pos, version_bits_params] : opts.version_bits_parameters) {
             consensus.vDeployments[deployment_pos].nStartTime = version_bits_params.start_time;
             consensus.vDeployments[deployment_pos].nTimeout = version_bits_params.timeout;
diff --git a/src/kernel/chainparams.h b/src/kernel/chainparams.h
index 34734a6fb48b..04139ea9b3a7 100644
--- a/src/kernel/chainparams.h
+++ b/src/kernel/chainparams.h
@@ -174,6 +174,10 @@ class CChainParams
         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<int> coinbase_maturity_rolling_start_height{};
+        std::optional<int> coinbase_maturity_rolling_enforce_height{};
+        std::optional<int> coinbase_maturity_rolling{};
+        std::optional<int> coinbase_maturity_rolling_end{};
     };
 
     static std::unique_ptr<const CChainParams> RegTest(const RegTestOptions& options);
diff --git a/src/node/interfaces.cpp b/src/node/interfaces.cpp
index 14fde63134bc..77a0beb64506 100644
--- a/src/node/interfaces.cpp
+++ b/src/node/interfaces.cpp
@@ -66,6 +66,7 @@
 
 #include <bitcoin-build-config.h> // IWYU pragma: keep
 
+#include <algorithm>
 #include <any>
 #include <memory>
 #include <optional>
@@ -90,6 +91,19 @@ namespace node {
 // All members of the classes in this namespace are intentionally public, as the
 // classes themselves are private.
 namespace {
+//! The maturity mempool policy requires for a generated coin mined at
+//! coin_height: the long maturity for every coin, raised to the rolling
+//! maturity for coins the rolling rule covers (mined at or above its start
+//! height and below its end coin height).
+int CoinbaseMaturityPolicy(const Consensus::Params& params, int coin_height)
+{
+    int maturity{params.CoinbaseMaturityLong};
+    if (coin_height >= params.CoinbaseMaturityRollingStartHeight && coin_height < params.CoinbaseMaturityRollingEndCoinHeight) {
+        maturity = std::max(maturity, params.CoinbaseMaturityRolling);
+    }
+    return maturity;
+}
+
 #ifdef ENABLE_EXTERNAL_SIGNER
 class ExternalSignerImpl : public interfaces::ExternalSigner
 {
@@ -335,7 +349,7 @@ class NodeImpl : public Node
         }
         return chainman().GetParams().GenesisBlock().GetBlockTime(); // Genesis block's time of current network
     }
-    int coinbaseMaturity() override { return chainman().GetConsensus().CoinbaseMaturityLong; }
+    int coinbaseMaturity(int coin_height) override { return CoinbaseMaturityPolicy(chainman().GetConsensus(), coin_height); }
     double getVerificationProgress() override
     {
         return chainman().GuessVerificationProgress(WITH_LOCK(chainman().GetMutex(), return chainman().ActiveChain().Tip()));
@@ -582,9 +596,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
+    int coinbaseMaturity(int coin_height) override
     {
-        return chainman().GetConsensus().CoinbaseMaturityLong;
+        return CoinbaseMaturityPolicy(chainman().GetConsensus(), coin_height);
     }
     bool pruneLockExists(const std::string& name) const override
     {
diff --git a/src/qt/transactiondesc.cpp b/src/qt/transactiondesc.cpp
index 8c5dc9ea017a..4c622c102581 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{node.coinbaseMaturity(status.block_height) + 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 8af7a86aae01..9d210e936194 100644
--- a/src/rpc/blockchain.cpp
+++ b/src/rpc/blockchain.cpp
@@ -1912,8 +1912,9 @@ 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 or rolling coinbase maturity rule (only for \"long_coinbase_maturity\" and \"rolling_coinbase_maturity\")"},
+    {RPCResult::Type::NUM, "coinbase_end_height", /*optional=*/true, "height of the last generated coin covered by the rolling coinbase maturity rule (only for \"rolling_coinbase_maturity\", and only if the coverage ends)"},
+    {RPCResult::Type::NUM, "maturity", /*optional=*/true, "required coinbase maturity depth for covered generated coins (only for \"long_coinbase_maturity\" and \"rolling_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)",
@@ -1976,6 +1977,23 @@ void LongCoinbaseMaturityDescPushBack(const CBlockIndex* blockindex, UniValue& s
     softforks.pushKV("long_coinbase_maturity", std::move(rv));
 }
 
+void RollingCoinbaseMaturityDescPushBack(const CBlockIndex* blockindex, UniValue& softforks, const ChainstateManager& chainman)
+{
+    const Consensus::Params& params{chainman.GetConsensus()};
+    if (params.CoinbaseMaturityRollingStartHeight == std::numeric_limits<int>::max()) return;
+
+    UniValue rv(UniValue::VOBJ);
+    rv.pushKV("type", "flagday");
+    rv.pushKV("height", params.CoinbaseMaturityRollingEnforceHeight);
+    rv.pushKV("coinbase_start_height", params.CoinbaseMaturityRollingStartHeight);
+    if (params.CoinbaseMaturityRollingEndCoinHeight != std::numeric_limits<int>::max()) {
+        rv.pushKV("coinbase_end_height", params.CoinbaseMaturityRollingEndCoinHeight - 1);
+    }
+    rv.pushKV("maturity", params.CoinbaseMaturityRolling);
+    rv.pushKV("active", params.CoinbaseMaturityRollingActiveAt(blockindex->nHeight + 1));
+    softforks.pushKV("rolling_coinbase_maturity", std::move(rv));
+}
+
 UniValue DeploymentInfo(const CBlockIndex* blockindex, const ChainstateManager& chainman)
 {
     UniValue softforks(UniValue::VOBJ);
@@ -1988,6 +2006,7 @@ UniValue DeploymentInfo(const CBlockIndex* blockindex, const ChainstateManager&
     SoftForkDescPushBack(blockindex, softforks, chainman, Consensus::DEPLOYMENT_TAPROOT);
     RdtsFlagDayDescPushBack(blockindex, softforks, chainman);
     LongCoinbaseMaturityDescPushBack(blockindex, softforks, chainman);
+    RollingCoinbaseMaturityDescPushBack(blockindex, softforks, chainman);
     return softforks;
 }
 } // anon namespace
diff --git a/src/rpc/mining.cpp b/src/rpc/mining.cpp
index 61565468fe05..2af9ac59e4ad 100644
--- a/src/rpc/mining.cpp
+++ b/src/rpc/mining.cpp
@@ -1087,6 +1087,9 @@ static UniValue TemplateToJSON(const Consensus::Params& consensusParams, const C
     if (pindexPrev != nullptr && consensusParams.CoinbaseMaturityLongActiveAt(pindexPrev->nHeight + 1)) {
         aRules.push_back("long_coinbase_maturity");
     }
+    if (pindexPrev != nullptr && consensusParams.CoinbaseMaturityRollingActiveAt(pindexPrev->nHeight + 1)) {
+        aRules.push_back("rolling_coinbase_maturity");
+    }
 
     result.pushKV("version", block_header.GetCompleteVersion());
     result.pushKV("rules", std::move(aRules));
diff --git a/src/test/coinbase_maturity_tests.cpp b/src/test/coinbase_maturity_tests.cpp
index 490c3ea8d38a..e6d92a32a630 100644
--- a/src/test/coinbase_maturity_tests.cpp
+++ b/src/test/coinbase_maturity_tests.cpp
@@ -4,7 +4,13 @@
 
 #include <chainparams.h>
 #include <consensus/consensus.h>
+#include <coins.h>
+#include <consensus/amount.h>
 #include <consensus/params.h>
+#include <consensus/tx_verify.h>
+#include <consensus/validation.h>
+#include <primitives/transaction.h>
+#include <script/script.h>
 
 #include <boost/test/unit_test.hpp>
 
@@ -33,7 +39,7 @@ BOOST_AUTO_TEST_CASE(long_maturity_derived_from_schedule)
         const auto& consensus{params->GetConsensus()};
         BOOST_CHECK_EQUAL(consensus.CoinbaseMaturityLong, consensus.CoinbaseMaturityLongReleaseHeight - consensus.CoinbaseMaturityLongStartHeight);
         BOOST_CHECK_GT(consensus.CoinbaseMaturityLong, COINBASE_MATURITY);
-        BOOST_REQUIRE_EQUAL(consensus.chainstate_revalidation_deployments.size(), 1);
+        BOOST_REQUIRE_GE(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);
@@ -64,4 +70,246 @@ BOOST_AUTO_TEST_CASE(long_maturity_derived_from_schedule)
     BOOST_CHECK_EQUAL(deployment.stop_height, 149);
 }
 
+BOOST_AUTO_TEST_CASE(rolling_maturity_mainnet_schedule)
+{
+    const auto main{CChainParams::Main()};
+    const auto& consensus{main->GetConsensus()};
+
+    // Covers every reward the long maturity window covers, takes over at the
+    // window's release height, and lasts 365 days of 144 blocks.
+    BOOST_CHECK_EQUAL(consensus.CoinbaseMaturityRollingStartHeight, 973440);
+    BOOST_CHECK_EQUAL(consensus.CoinbaseMaturityRollingStartHeight, consensus.CoinbaseMaturityLongStartHeight);
+    BOOST_CHECK_EQUAL(consensus.CoinbaseMaturityRollingEnforceHeight, 979920);
+    BOOST_CHECK_EQUAL(consensus.CoinbaseMaturityRollingEnforceHeight, consensus.CoinbaseMaturityLongReleaseHeight);
+    BOOST_CHECK_EQUAL(consensus.CoinbaseMaturityRolling, 365 * 144);
+
+    BOOST_CHECK(!consensus.CoinbaseMaturityRollingActiveAt(979919));
+    BOOST_CHECK(consensus.CoinbaseMaturityRollingActiveAt(979920));
+    BOOST_CHECK(consensus.CoinbaseMaturityRollingActiveAt(std::numeric_limits<int>::max() - 1));
+
+    // Coverage ends at the first zero-subsidy height (33 halvings of 210000
+    // blocks): the last covered reward is 6929999, rewards from 6930000 on
+    // keep the maturity the earlier rules require (plain COINBASE_MATURITY,
+    // the long window being long gone by then).
+    BOOST_CHECK_EQUAL(consensus.CoinbaseMaturityRollingEndCoinHeight, 33 * 210000);
+    BOOST_CHECK_EQUAL(consensus.CoinbaseMaturityRollingEndCoinHeight, 6930000);
+    BOOST_CHECK_EQUAL(consensus.CoinbaseMaturityRequired(6929999, 6929999 + 52560), 52560);
+    BOOST_CHECK_GT(consensus.CoinbaseMaturityRequired(6929999, 6929999 + COINBASE_MATURITY), COINBASE_MATURITY);
+    BOOST_CHECK_EQUAL(consensus.CoinbaseMaturityRequired(6930000, 6930000 + COINBASE_MATURITY), COINBASE_MATURITY);
+    BOOST_CHECK_EQUAL(consensus.CoinbaseMaturityRequired(7000000, 7000000 + COINBASE_MATURITY), COINBASE_MATURITY);
+
+    BOOST_REQUIRE_EQUAL(consensus.chainstate_revalidation_deployments.size(), 2);
+    const auto& deployment{consensus.chainstate_revalidation_deployments.back()};
+    BOOST_CHECK_EQUAL(deployment.name, "rolling_coinbase_maturity_1y");
+    BOOST_CHECK_EQUAL(deployment.start_height, 979920);
+    BOOST_CHECK_EQUAL(deployment.stop_height, std::numeric_limits<int>::max());
+
+    // Other chains are untouched.
+    const auto testnet4{CChainParams::TestNet4()};
+    BOOST_CHECK(!testnet4->GetConsensus().CoinbaseMaturityRollingActiveAt(std::numeric_limits<int>::max() - 1));
+    const auto regtest_default{CChainParams::RegTest({})};
+    BOOST_CHECK(!regtest_default->GetConsensus().CoinbaseMaturityRollingActiveAt(std::numeric_limits<int>::max() - 1));
+
+    CChainParams::RegTestOptions options;
+    options.coinbase_maturity_rolling_start_height = 10;
+    options.coinbase_maturity_rolling_enforce_height = 20;
+    options.coinbase_maturity_rolling = 150;
+    const auto regtest{CChainParams::RegTest(options)};
+    BOOST_CHECK_EQUAL(regtest->GetConsensus().CoinbaseMaturityRolling, 150);
+    BOOST_CHECK(!regtest->GetConsensus().CoinbaseMaturityRollingActiveAt(19));
+    BOOST_CHECK(regtest->GetConsensus().CoinbaseMaturityRollingActiveAt(20));
+    // Without an explicit end the coverage never ends.
+    BOOST_CHECK_EQUAL(regtest->GetConsensus().CoinbaseMaturityRollingEndCoinHeight, std::numeric_limits<int>::max());
+
+    options.coinbase_maturity_rolling_end = 40;
+    const auto regtest_end{CChainParams::RegTest(options)};
+    BOOST_CHECK_EQUAL(regtest_end->GetConsensus().CoinbaseMaturityRollingEndCoinHeight, 40);
+    BOOST_CHECK_EQUAL(regtest_end->GetConsensus().CoinbaseMaturityRequired(39, 39 + 150), 150);
+    BOOST_CHECK_EQUAL(regtest_end->GetConsensus().CoinbaseMaturityRequired(40, 40 + COINBASE_MATURITY), COINBASE_MATURITY);
+}
+
+namespace {
+//! First height at which a block may spend a reward mined at coin_height.
+//! Spendability only changes at these breakpoints, so checking each is exact.
+int ReleaseHeight(const Consensus::Params& params, int coin_height)
+{
+    int release{std::numeric_limits<int>::max()};
+    for (const int maturity : {COINBASE_MATURITY, params.CoinbaseMaturityLong, params.CoinbaseMaturityRolling}) {
+        for (const int candidate : {coin_height + maturity, params.CoinbaseMaturityLongEnforceHeight,
+                                    params.CoinbaseMaturityLongReleaseHeight, params.CoinbaseMaturityRollingEnforceHeight}) {
+            if (candidate <= coin_height || candidate == std::numeric_limits<int>::max()) continue;
+            if (candidate - coin_height >= params.CoinbaseMaturityRequired(coin_height, candidate)) {
+                release = std::min(release, candidate);
+            }
+        }
+    }
+    return release;
+}
+} // namespace
+
+BOOST_AUTO_TEST_CASE(rolling_maturity_releases_one_reward_per_block)
+{
+    const auto main{CChainParams::Main()};
+    const auto& consensus{main->GetConsensus()};
+
+    // Without the rolling rule, the long window releases every reward it holds
+    // together at 979920.
+    Consensus::Params window_only{consensus};
+    window_only.CoinbaseMaturityRollingStartHeight = std::numeric_limits<int>::max();
+    window_only.CoinbaseMaturityRollingEnforceHeight = std::numeric_limits<int>::max();
+    int cliff{0};
+    for (int coin_height{973440}; coin_height < 979920; ++coin_height) {
+        if (ReleaseHeight(window_only, coin_height) == 979920) ++cliff;
+    }
+    BOOST_CHECK_GT(cliff, 6000);
+
+    // With it, every reward from 973440 on unlocks exactly 52560 blocks after
+    // it was mined, so no two rewards ever unlock at the same height.
+    for (int coin_height{973440}; coin_height < 1200000; ++coin_height) {
+        const int release{ReleaseHeight(consensus, coin_height)};
+        if (release != coin_height + 52560) {
+            BOOST_FAIL("reward at " << coin_height << " unlocks at " << release);
+        }
+    }
+    BOOST_CHECK_EQUAL(ReleaseHeight(consensus, 973440), 1026000);
+
+    // Rewards from before the window keep ordinary maturity.
+    BOOST_CHECK_EQUAL(ReleaseHeight(consensus, 973439), 973439 + COINBASE_MATURITY);
+    BOOST_CHECK_EQUAL(ReleaseHeight(consensus, 960000), 960000 + COINBASE_MATURITY);
+
+    // Through 979919 nothing changes from the rules already enforced.
+    for (int spend_height{973440}; spend_height < 979920; spend_height += 7) {
+        for (int coin_height{spend_height - 7000}; coin_height < spend_height; coin_height += 13) {
+            BOOST_CHECK_EQUAL(consensus.CoinbaseMaturityRequired(coin_height, spend_height),
+                              window_only.CoinbaseMaturityRequired(coin_height, spend_height));
+        }
+    }
+}
+
+BOOST_AUTO_TEST_CASE(rolling_maturity_independent_of_rdts)
+{
+    // The rule is decided by heights alone. Moving or removing the RDTS expiry,
+    // or the BLAKE2b fork it hangs from, changes nothing about it.
+    const auto main{CChainParams::Main()};
+    const auto& consensus{main->GetConsensus()};
+    for (const int64_t expiry : {std::numeric_limits<int64_t>::min(), int64_t{0}, int64_t{1819756800}, std::numeric_limits<int64_t>::max()}) {
+        Consensus::Params changed{consensus};
+        changed.RdtsExpiryTime = expiry;
+        for (const int blake2b_height : {consensus.Blake2bHeight, std::numeric_limits<int>::max()}) {
+            changed.Blake2bHeight = blake2b_height;
+            for (int coin_height{973000}; coin_height < 1100000; coin_height += 997) {
+                for (const int depth : {100, 6479, 6480, 52559, 52560}) {
+                    BOOST_CHECK_EQUAL(changed.CoinbaseMaturityRequired(coin_height, coin_height + depth),
+                                      consensus.CoinbaseMaturityRequired(coin_height, coin_height + depth));
+                }
+            }
+        }
+    }
+}
+
+BOOST_AUTO_TEST_CASE(rolling_maturity_clean_activation_after_release)
+{
+    // An enforce height A is "clean" when no covered reward was ever
+    // spendable under the earlier rules before A, which holds whenever
+    // A <= StartHeight + required_prior: enforcement then only extends
+    // maturities that are still pending and never re-locks a coin some
+    // node may already have seen spent.
+    //
+    // Mainnet mapping for an enforce height after 979920: if the shipped
+    // interim rule is the rolling-180d maturity (25920 blocks), the bound
+    // is enforce < 979919 + 25920 = 1005839; if the shipped interim rule
+    // is the freeze-by-RDTS-expiry, covered rewards stay locked until the
+    // expiry, so any enforce height before it is clean.
+    Consensus::Params params;
+    params.CoinbaseMaturityLongStartHeight = 200;
+    params.CoinbaseMaturityLongEnforceHeight = 200;
+    params.CoinbaseMaturityLongReleaseHeight = 300;
+    params.CoinbaseMaturityLong = params.CoinbaseMaturityLongReleaseHeight - params.CoinbaseMaturityLongStartHeight;
+    params.CoinbaseMaturityRollingStartHeight = 200;
+    params.CoinbaseMaturityRollingEnforceHeight = 290;
+    params.CoinbaseMaturityRolling = 500;
+    params.CoinbaseMaturityRollingEndCoinHeight = 10000;
+
+    const int A{params.CoinbaseMaturityRollingEnforceHeight};
+    // The clean-activation precondition: every covered reward mined before A
+    // still needs at least A - StartHeight blocks under the earlier rules.
+    BOOST_CHECK_LE(A, params.CoinbaseMaturityLongStartHeight + params.CoinbaseMaturityLong);
+
+    for (int coin_height{params.CoinbaseMaturityRollingStartHeight}; coin_height < A; ++coin_height) {
+        // Before A no covered reward was ever spendable: the earlier rules
+        // alone already required more depth than any pre-A block offers.
+        for (int spend_height{coin_height + 1}; spend_height < A; ++spend_height) {
+            BOOST_CHECK_GT(params.CoinbaseMaturityRequired(coin_height, spend_height), spend_height - coin_height);
+        }
+        // From A on the requirement is the larger of the earlier rules and
+        // the rolling depth; with the rolling depth dominating here, exactly
+        // the rolling depth.
+        for (const int spend_height : {A, A + 1, coin_height + 499, coin_height + 500, coin_height + 5000}) {
+            if (spend_height < A) continue;
+            Consensus::Params prior{params};
+            prior.CoinbaseMaturityRollingEnforceHeight = std::numeric_limits<int>::max();
+            BOOST_CHECK_EQUAL(params.CoinbaseMaturityRequired(coin_height, spend_height),
+                              std::max(prior.CoinbaseMaturityRequired(coin_height, spend_height), params.CoinbaseMaturityRolling));
+        }
+    }
+}
+
+BOOST_AUTO_TEST_CASE(rolling_maturity_check_tx_inputs)
+{
+    // Each covered reward needs the full rolling depth from its own block;
+    // older rewards keep the rules that applied before.
+    constexpr int ROLLING_START{1000};
+    constexpr int ROLLING{5000};
+    constexpr int LONG_START{500};
+    constexpr int LONG{700};
+
+    CCoinsView base;
+    CCoinsViewCache view{&base};
+
+    const auto spend_at{[&](int coin_height, int spend_height, int long_start, int rolling_end = std::numeric_limits<int>::max()) {
+        CMutableTransaction cb;
+        cb.vin.resize(1);
+        cb.vin[0].prevout.SetNull();
+        cb.vout.resize(1);
+        cb.vout[0].nValue = 50 * COIN;
+        cb.vout[0].scriptPubKey = CScript() << OP_TRUE;
+        cb.nLockTime = coin_height; // distinct txid per height
+        const CTransaction coinbase{cb};
+        AddCoins(view, coinbase, coin_height);
+
+        CMutableTransaction spend;
+        spend.vin.emplace_back(COutPoint{coinbase.GetHash(), 0});
+        spend.vout.emplace_back(49 * COIN, CScript() << OP_TRUE);
+        TxValidationState state;
+        CAmount fee;
+        return Consensus::CheckTxInputs(CTransaction{spend}, state, view, spend_height, fee, CheckTxInputsRules::None,
+                                        LONG, long_start, ROLLING, ROLLING_START, rolling_end);
+    }};
+
+    // Before the rolling start height: only the existing rules.
+    BOOST_CHECK(spend_at(ROLLING_START - 1, ROLLING_START - 1 + COINBASE_MATURITY, std::numeric_limits<int>::max()));
+    BOOST_CHECK(!spend_at(ROLLING_START - 2, ROLLING_START - 2 + LONG - 1, LONG_START));
+    BOOST_CHECK(spend_at(ROLLING_START - 3, ROLLING_START - 3 + LONG, LONG_START));
+
+    // From the rolling start height: one block short fails, exact depth passes.
+    for (const int coin_height : {ROLLING_START, ROLLING_START + 1, ROLLING_START + 12345}) {
+        BOOST_CHECK(!spend_at(coin_height, coin_height + COINBASE_MATURITY, std::numeric_limits<int>::max()));
+        BOOST_CHECK(!spend_at(coin_height, coin_height + ROLLING - 1, std::numeric_limits<int>::max()));
+        BOOST_CHECK(spend_at(coin_height, coin_height + ROLLING, std::numeric_limits<int>::max()));
+    }
+
+    // When the long rule also covers the coin, the longer of the two applies.
+    BOOST_CHECK(!spend_at(ROLLING_START + 7, ROLLING_START + 7 + LONG, 0));
+    BOOST_CHECK(spend_at(ROLLING_START + 8, ROLLING_START + 8 + ROLLING, 0));
+
+    // With an end coin height, the reward mined just below it stays covered
+    // while the one mined at it keeps only the earlier rules.
+    constexpr int ROLLING_END{ROLLING_START + 100};
+    BOOST_CHECK(!spend_at(ROLLING_END - 1, ROLLING_END - 1 + ROLLING - 1, std::numeric_limits<int>::max(), ROLLING_END));
+    BOOST_CHECK(spend_at(ROLLING_END - 1, ROLLING_END - 1 + ROLLING, std::numeric_limits<int>::max(), ROLLING_END));
+    BOOST_CHECK(spend_at(ROLLING_END, ROLLING_END + COINBASE_MATURITY, std::numeric_limits<int>::max(), ROLLING_END));
+    BOOST_CHECK(!spend_at(ROLLING_END + 1, ROLLING_END + 1 + LONG - 1, 0, ROLLING_END));
+    BOOST_CHECK(spend_at(ROLLING_END + 2, ROLLING_END + 2 + LONG, 0, ROLLING_END));
+}
+
 BOOST_AUTO_TEST_SUITE_END()
diff --git a/src/validation.cpp b/src/validation.cpp
index 26661fbee5aa..8177105f1cc0 100644
--- a/src/validation.cpp
+++ b/src/validation.cpp
@@ -443,6 +443,12 @@ void Chainstate::MaybeUpdateMempoolForReorg(
                 if (coin.IsCoinBase() && mempool_spend_height - coin.nHeight < consensusParams.CoinbaseMaturityLong) {
                     return true;
                 }
+                if (coin.IsCoinBase() && consensusParams.CoinbaseMaturityRollingActiveAt(mempool_spend_height) &&
+                    (int)coin.nHeight >= consensusParams.CoinbaseMaturityRollingStartHeight &&
+                    (int)coin.nHeight < consensusParams.CoinbaseMaturityRollingEndCoinHeight &&
+                    mempool_spend_height - coin.nHeight < consensusParams.CoinbaseMaturityRolling) {
+                    return true;
+                }
             }
         }
         // Transaction is still valid and cached LockPoints are updated.
@@ -1020,7 +1026,10 @@ bool MemPoolAccept::PreChecks(ATMPArgs& args, Workspace& ws)
     const auto& consensusParams{args.m_chainparams.GetConsensus()};
     if (!Consensus::CheckTxInputs(tx, state, m_view, block_height_next, ws.m_base_fees, CheckTxInputsRules::OutputSizeLimit,
                                   consensusParams.CoinbaseMaturityLong,
-                                  /*long_maturity_start_height=*/ 0)) {
+                                  /*long_maturity_start_height=*/ 0,
+                                  consensusParams.CoinbaseMaturityRolling,
+                                  consensusParams.CoinbaseMaturityRollingActiveAt(block_height_next) ? consensusParams.CoinbaseMaturityRollingStartHeight : std::numeric_limits<int>::max(),
+                                  consensusParams.CoinbaseMaturityRollingEndCoinHeight)) {
         return false; // state filled in by CheckTxInputs
     }
 
@@ -3011,6 +3020,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 rolling_maturity_start_height{consensusParams.CoinbaseMaturityRollingActiveAt(pindex->nHeight) ? consensusParams.CoinbaseMaturityRollingStartHeight : std::numeric_limits<int>::max()};
 
     std::vector<int> prevheights;
     CAmount nFees = 0;
@@ -3031,7 +3041,10 @@ bool Chainstate::ConnectBlock(const CBlock& block, BlockValidationState& state,
             TxValidationState tx_state;
             if (!Consensus::CheckTxInputs(tx, tx_state, view, pindex->nHeight, txfee, chk_input_rules,
                                           consensusParams.CoinbaseMaturityLong,
-                                          long_maturity_start_height)) {
+                                          long_maturity_start_height,
+                                          consensusParams.CoinbaseMaturityRolling,
+                                          rolling_maturity_start_height,
+                                          consensusParams.CoinbaseMaturityRollingEndCoinHeight)) {
                 // 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..f16a6ad46d5a 100644
--- a/src/wallet/wallet.cpp
+++ b/src/wallet/wallet.cpp
@@ -3646,7 +3646,9 @@ 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};
+    // The rolling rule makes maturity depend on the height the coin was mined at.
+    const int coin_height{GetLastBlockHeight() - chain_depth + 1};
+    const int maturity{HaveChain() ? chain().coinbaseMaturity(coin_height) : COINBASE_MATURITY};
     return std::max(0, (maturity + 1) - chain_depth);
 }
 
diff --git a/test/functional/feature_rolling_maturity_end_bound.py b/test/functional/feature_rolling_maturity_end_bound.py
new file mode 100755
index 000000000000..c0791cf5607b
--- /dev/null
+++ b/test/functional/feature_rolling_maturity_end_bound.py
@@ -0,0 +1,113 @@
+#!/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.
+"""Rolling maturity coverage ends at the end coin height and starts at the enforce height."""
+from test_framework.blocktools import add_witness_commitment, create_block, create_coinbase
+from test_framework.test_framework import BitcoinTestFramework
+from test_framework.util import assert_equal, assert_raises_rpc_error
+from test_framework.wallet import MiniWallet
+
+START = 200    # first covered coin height
+ENFORCE = 320  # first height enforcing the rolling rule
+DEPTH = 300
+END = 203      # first non-covered coin height (zero-subsidy analog)
+
+
+class RollingMaturityEndBoundTest(BitcoinTestFramework):
+    def set_test_params(self):
+        self.num_nodes = 1
+        self.setup_clean_chain = True
+        self.extra_args = [[
+            f"-testcoinbasematurityrolling={START}:{ENFORCE}:{DEPTH}:{END}",
+            "-checkmempool=1",
+        ]]
+
+    def block(self, txs=None):
+        node = self.nodes[0]
+        height = node.getblockcount() + 1
+        tip = node.getbestblockhash()
+        block = create_block(int(tip, 16), create_coinbase(
+            height, script_pubkey=self.mini.get_output_script()),
+            node.getblockheader(tip)["time"] + 1,
+            height=height, txlist=txs)
+        add_witness_commitment(block)
+        block.solve()
+        return block
+
+    def submit(self, block, expected=None):
+        assert_equal(self.nodes[0].submitblock(block.serialize().hex()), expected)
+
+    def spend(self, height):
+        node = self.nodes[0]
+        self.mini.rescan_utxos()
+        txid = node.getblock(node.getblockhash(height))["tx"][0]
+        return self.mini.create_self_transfer(utxo_to_spend=self.mini.get_utxo(txid=txid))
+
+    def deployment(self):
+        info = self.nodes[0].getdeploymentinfo()["deployments"]
+        return info["rolling_coinbase_maturity"]
+
+    def run_test(self):
+        node = self.nodes[0]
+        self.mini = MiniWallet(node)
+
+        self.log.info("Deployment reports the last covered coin height")
+        self.generate(self.mini, 310)
+        dep = self.deployment()
+        assert_equal(dep["type"], "flagday")
+        assert_equal(dep["height"], ENFORCE)
+        assert_equal(dep["coinbase_start_height"], START)
+        assert_equal(dep["coinbase_end_height"], END - 1)
+        assert_equal(dep["maturity"], DEPTH)
+        assert_equal(dep["active"], False)
+
+        self.log.info("Before enforcement a covered reward spends at 100, in mempool and in a block")
+        pre = self.spend(START)  # depth 111: past 100, far short of DEPTH
+        node.sendrawtransaction(pre["hex"])  # policy follows consensus: no early hold
+        self.submit(self.block(txs=[pre["tx"]]))
+
+        self.log.info("From enforcement covered rewards need the full depth")
+        self.generate(self.mini, ENFORCE - node.getblockcount())
+        assert node.getblockcount() >= ENFORCE
+        assert_equal(self.deployment()["active"], True)
+        covered = self.spend(START + 1)  # depth ~120 < DEPTH
+        assert_raises_rpc_error(-26, "premature-spend-of-coinbase",
+                                node.sendrawtransaction, covered["hex"])
+        self.submit(self.block(txs=[covered["tx"]]), "bad-txns-premature-spend-of-coinbase")
+
+        self.log.info("Rewards past the end coin height keep the historical 100")
+        node.sendrawtransaction(self.spend(END)["hex"])
+        self.generate(self.mini, 1)
+
+        self.log.info("Rewards from before the start height are untouched too")
+        node.sendrawtransaction(self.spend(START - 1)["hex"])
+        self.generate(self.mini, 1)
+
+        self.log.info("The rule survives a restart")
+        self.restart_node(0, extra_args=self.extra_args[0])
+        self.mini.rescan_utxos()
+        assert_equal(self.deployment()["active"], True)
+        assert_equal(self.deployment()["coinbase_end_height"], END - 1)
+        still_covered = self.spend(START + 1)
+        assert_raises_rpc_error(-26, "premature-spend-of-coinbase",
+                                node.sendrawtransaction, still_covered["hex"])
+
+        self.log.info("Exact depth boundary: DEPTH-1 fails, DEPTH succeeds")
+        target = START + 1 + DEPTH  # first height whose block may spend coin START+1
+        self.generate(self.mini, target - 2 - node.getblockcount())
+        assert_equal(node.getblockcount(), target - 2)  # next block: depth DEPTH-1
+        too_early = self.spend(START + 1)
+        self.submit(self.block(txs=[too_early["tx"]]), "bad-txns-premature-spend-of-coinbase")
+        self.generate(self.mini, 1)  # next block height == target: depth DEPTH
+        at_depth = self.spend(START + 1)
+        self.submit(self.block(txs=[at_depth["tx"]]))
+
+        self.log.info("The last covered reward unlocks at its own full depth")
+        assert_equal(node.getblockcount() + 1, END - 1 + DEPTH)
+        node.sendrawtransaction(self.spend(END - 1)["hex"])
+        self.generate(self.mini, 1)
+
+
+if __name__ == '__main__':
+    RollingMaturityEndBoundTest(__file__).main()
diff --git a/test/functional/mempool_rolling_coinbase_maturity.py b/test/functional/mempool_rolling_coinbase_maturity.py
new file mode 100755
index 000000000000..a541525382b8
--- /dev/null
+++ b/test/functional/mempool_rolling_coinbase_maturity.py
@@ -0,0 +1,190 @@
+#!/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 rolling coinbase maturity policy and consensus.
+
+Mirrors mainnet at a small scale: a long maturity window holds rewards from
+START until RELEASE, and the rolling rule takes over at RELEASE for every
+reward from START on. Each reward then unlocks ROLLING_MATURITY blocks after
+its own block, one per block, instead of all of them together at RELEASE.
+
+The same checks run on three nodes, without RDTS, with RDTS active, and with
+RDTS already expired, since the rule must not depend on RDTS.
+"""
+
+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
+
+START_HEIGHT = 110
+RELEASE_HEIGHT = START_HEIGHT + COINBASE_MATURITY + 6
+LONG_MATURITY = RELEASE_HEIGHT - START_HEIGHT
+ROLLING_MATURITY = COINBASE_MATURITY + 50
+DEPLOYMENT = "rolling_coinbase_maturity"
+FORK_HEIGHT = 2
+PREMATURE = "bad-txns-premature-spend-of-coinbase"
+
+BASE_ARGS = [
+    f"-testcoinbasematuritylong={START_HEIGHT}:{START_HEIGHT}:{RELEASE_HEIGHT}",
+    f"-testcoinbasematurityrolling={START_HEIGHT}:{RELEASE_HEIGHT}:{ROLLING_MATURITY}",
+    "-checkmempool=1",
+]
+# name, extra args, whether RDTS is enforced once blocks are being mined
+MODES = [
+    ("without RDTS", [], None),
+    ("with RDTS active", [f"-testactivationheight=blake2b@{FORK_HEIGHT}", "-rdtsexpiry=4102444800"], True),
+    ("with RDTS expired", [f"-testactivationheight=blake2b@{FORK_HEIGHT}", "-rdtsexpiry=1296688603"], False),
+]
+
+
+class RollingCoinbaseMaturityTest(BitcoinTestFramework):
+    def set_test_params(self):
+        self.num_nodes = len(MODES)
+        self.setup_clean_chain = True
+        self.extra_args = [BASE_ARGS + extra for _, extra, _ in MODES]
+
+    def setup_network(self):
+        # Each node is its own chain.
+        self.setup_nodes()
+
+    def create_next_block(self, node, txs=None):
+        tip = node.getbestblockhash()
+        height = node.getblockcount() + 1
+        block = create_block(
+            int(tip, 16),
+            create_coinbase(height, script_pubkey=self.wallet.get_output_script()),
+            node.getblockheader(tip)["time"] + 1,
+            height=height,
+            txlist=txs,
+            header_v2=self.rdts is not None and height >= FORK_HEIGHT,
+        )
+        add_witness_commitment(block)
+        block.solve()
+        return block
+
+    def submit(self, node, txs=None):
+        return node.submitblock(self.create_next_block(node, txs).serialize().hex())
+
+    def coinbase_spend(self, node, height):
+        txid = node.getblock(node.getblockhash(height))["tx"][0]
+        if not any(u["txid"] == txid for u in self.wallet._utxos):
+            self.wallet.rescan_utxos(include_mempool=False)
+        return self.wallet.create_self_transfer(utxo_to_spend=self.wallet.get_utxo(txid=txid, mark_as_spent=False))
+
+    def mine_to(self, node, height):
+        while node.getblockcount() < height:
+            assert_equal(self.submit(node), None)
+
+    def assert_deployment(self, node, active):
+        deployment = node.getdeploymentinfo()["deployments"][DEPLOYMENT]
+        assert_equal(deployment["type"], "flagday")
+        assert_equal(deployment["height"], RELEASE_HEIGHT)
+        assert_equal(deployment["coinbase_start_height"], START_HEIGHT)
+        assert_equal(deployment["maturity"], ROLLING_MATURITY)
+        assert "height_end" not in deployment
+        assert "expiry_time" not in deployment
+        assert_equal(deployment["active"], active)
+        rules = ["segwit"] + (["blake2b"] if self.rdts is not None else [])
+        assert_equal(DEPLOYMENT in node.getblocktemplate({"rules": rules})["rules"], active)
+
+    def assert_rdts(self, node):
+        if self.rdts is None:
+            return
+        assert_equal(node.getdeploymentinfo()["deployments"]["reduced_data"]["active"], self.rdts)
+
+    def check_rejected_schedules(self):
+        node = self.nodes[0]
+        self.stop_node(0)
+        for args, msg in [
+            (["-testcoinbasematurityrolling=150:200"], "Invalid format"),
+            (["-testcoinbasematurityrolling=1:2:3:4:5"], "Invalid format"),
+            (["-testcoinbasematurityrolling=-1:200:200"], "Invalid start height"),
+            (["-testcoinbasematurityrolling=99999999999999999999:200:200"], "Invalid start height"),
+            (["-testcoinbasematurityrolling=150:1:200"], "Invalid enforce height"),
+            ([f"-testcoinbasematurityrolling=150:200:{COINBASE_MATURITY}"], "Invalid maturity"),
+            (["-testcoinbasematurityrolling=150:200:200:150"], "Invalid end coin height"),
+            (["-testcoinbasematurityrolling=150:200:200:149"], "Invalid end coin height"),
+        ]:
+            node.assert_start_raises_init_error(extra_args=args, expected_msg=msg, match=ErrorMatch.PARTIAL_REGEX)
+        self.start_node(0, extra_args=self.extra_args[0].copy())
+
+    def run_mode(self, n):
+        name, _, self.rdts = MODES[n]
+        node = self.nodes[n]
+        self.log.info(f"Node {n}, {name}")
+        self.wallet = MiniWallet(node)
+        self.generate(self.wallet, 10, sync_fun=self.no_op)
+        self.mine_to(node, START_HEIGHT - 1 + COINBASE_MATURITY - 1)
+        self.assert_rdts(node)
+
+        self.log.info("  A reward from before the start height keeps ordinary maturity")
+        old = self.coinbase_spend(node, START_HEIGHT - 1)
+        assert_equal(self.submit(node, [old["tx"]]), None)
+
+        self.mine_to(node, RELEASE_HEIGHT - 2)
+        self.assert_deployment(node, active=False)
+        self.mine_to(node, RELEASE_HEIGHT - 1)
+        self.assert_deployment(node, active=True)
+
+        self.log.info("  Nothing is released together at the window's release height")
+        # Without the rolling rule, every reward from START to RELEASE - 100
+        # would become spendable in this one block.
+        for coin_height in range(START_HEIGHT, RELEASE_HEIGHT - COINBASE_MATURITY + 1):
+            spend = self.coinbase_spend(node, coin_height)
+            assert_equal(self.submit(node, [spend["tx"]]), PREMATURE)
+            assert_raises_rpc_error(-26, PREMATURE, node.sendrawtransaction, spend["hex"])
+        assert_equal(node.getblockcount(), RELEASE_HEIGHT - 1)
+
+        self.log.info("  Each reward unlocks on its own block, one per block")
+        self.mine_to(node, START_HEIGHT + ROLLING_MATURITY - 2)
+        first = self.coinbase_spend(node, START_HEIGHT)
+        assert_equal(self.submit(node, [first["tx"]]), PREMATURE)
+        assert_raises_rpc_error(-26, PREMATURE, node.sendrawtransaction, first["hex"])
+        for coin_height in range(START_HEIGHT, START_HEIGHT + 4):
+            # The next block is exactly ROLLING_MATURITY above this reward and
+            # one short for the reward mined right after it.
+            self.mine_to(node, coin_height + ROLLING_MATURITY - 1)
+            spend = self.coinbase_spend(node, coin_height)
+            nxt = self.coinbase_spend(node, coin_height + 1)
+            assert_equal(self.submit(node, [nxt["tx"]]), PREMATURE)
+            assert_raises_rpc_error(-26, PREMATURE, node.sendrawtransaction, nxt["hex"])
+            node.sendrawtransaction(spend["hex"])
+            assert spend["txid"] in node.getrawmempool()
+
+            if coin_height == START_HEIGHT:
+                self.log.info("  A reorg that makes the spend premature again evicts it from the mempool")
+                tip_hash = node.getbestblockhash()
+                node.invalidateblock(tip_hash)
+                assert spend["txid"] not in node.getrawmempool()
+                node.reconsiderblock(tip_hash)
+                node.sendrawtransaction(spend["hex"])
+
+            assert_equal(self.submit(node, [spend["tx"]]), None)
+            assert_equal(node.getblockcount(), coin_height + ROLLING_MATURITY)
+
+        self.assert_rdts(node)
+        self.assert_deployment(node, active=True)
+
+        self.log.info("  The rule still holds after a restart")
+        self.restart_node(n)
+        self.assert_deployment(node, active=True)
+        spend = self.coinbase_spend(node, START_HEIGHT + 10)
+        assert_raises_rpc_error(-26, PREMATURE, node.sendrawtransaction, spend["hex"])
+        assert_equal(self.submit(node, [spend["tx"]]), PREMATURE)
+
+    def run_test(self):
+        self.check_rejected_schedules()
+        for n in range(len(MODES)):
+            self.run_mode(n)
+
+
+if __name__ == "__main__":
+    RollingCoinbaseMaturityTest(__file__).main()
diff --git a/test/functional/test_runner.py b/test/functional/test_runner.py
index 337d66721045..6bba85b86019 100755
--- a/test/functional/test_runner.py
+++ b/test/functional/test_runner.py
@@ -224,6 +224,8 @@
     'interface_rest.py',
     'feature_chainstate_revalidation.py',
     'mempool_long_coinbase_maturity.py',
+    'mempool_rolling_coinbase_maturity.py',
+    'feature_rolling_maturity_end_bound.py',
     'mempool_spend_coinbase.py',
     'wallet_avoid_mixing_output_types.py --descriptors',
     'mempool_reorg.py',