diff --git a/src/chainparams.cpp b/src/chainparams.cpp
index ed2a4c1571..aa7f0361fd 100644
--- a/src/chainparams.cpp
+++ b/src/chainparams.cpp
@@ -118,6 +118,7 @@ class CMainParams : public CChainParams {
         consensus.BayfrontHeight = 405000;
         consensus.BayfrontMarinaHeight = 465150;
         consensus.BayfrontGardensHeight = 488300;
+        consensus.ClarkeQuayHeight = 595738;
 
         consensus.pos.diffLimit = uint256S("00000fffffffffffffffffffffffffffffffffffffffffffffffffffffffffff");
 //        consensus.pos.nTargetTimespan = 14 * 24 * 60 * 60; // two weeks
@@ -279,6 +280,7 @@ class CTestNetParams : public CChainParams {
         consensus.BayfrontHeight = 3000;
         consensus.BayfrontMarinaHeight = 90470;
         consensus.BayfrontGardensHeight = 101342;
+        consensus.ClarkeQuayHeight = 155000;
 
         consensus.pos.diffLimit = uint256S("00000fffffffffffffffffffffffffffffffffffffffffffffffffffffffffff");
 //        consensus.pos.nTargetTimespan = 14 * 24 * 60 * 60; // two weeks
@@ -415,8 +417,9 @@ class CDevNetParams : public CChainParams {
         consensus.BIP66Height = 0;
         consensus.AMKHeight = 150;
         consensus.BayfrontHeight = 250;
-        consensus.BayfrontMarinaHeight = 0;
-        consensus.BayfrontGardensHeight = 0;
+        consensus.BayfrontMarinaHeight = 300;
+        consensus.BayfrontGardensHeight = 300;
+        consensus.ClarkeQuayHeight = 500;
 
         consensus.pos.diffLimit = uint256S("00000fffffffffffffffffffffffffffffffffffffffffffffffffffffffffff");
         consensus.pos.nTargetTimespan = 5 * 60; // 5 min == 10 blocks
@@ -550,6 +553,7 @@ class CRegTestParams : public CChainParams {
         consensus.BayfrontHeight = 10000000;
         consensus.BayfrontMarinaHeight = 10000000;
         consensus.BayfrontGardensHeight = 10000000;
+        consensus.ClarkeQuayHeight = 10000000;
 
         consensus.pos.diffLimit = uint256S("00000fffffffffffffffffffffffffffffffffffffffffffffffffffffffffff");
         consensus.pos.nTargetTimespan = 14 * 24 * 60 * 60; // two weeks
@@ -726,6 +730,17 @@ void CRegTestParams::UpdateActivationParametersFromArgs(const ArgsManager& args)
         consensus.BayfrontGardensHeight = static_cast<int>(height);
     }
 
+    if (gArgs.IsArgSet("-clarkequayheight")) {
+        int64_t height = gArgs.GetArg("-clarkequayheight", consensus.ClarkeQuayHeight);
+        if (height < -1 || height >= std::numeric_limits<int>::max()) {
+            throw std::runtime_error(strprintf("Activation height %ld for ClarkeQuay is out of valid range. Use -1 to disable clarkequay features.", height));
+        } else if (height == -1) {
+            LogPrintf("CQ disabled for testing\n");
+            height = std::numeric_limits<int>::max();
+        }
+        consensus.ClarkeQuayHeight = static_cast<int>(height);
+    }
+
     if (!args.IsArgSet("-vbparams")) return;
 
     for (const std::string& strDeployment : args.GetArgs("-vbparams")) {
diff --git a/src/consensus/params.h b/src/consensus/params.h
index 1155371cc2..bbdee88da9 100644
--- a/src/consensus/params.h
+++ b/src/consensus/params.h
@@ -76,6 +76,8 @@ struct Params {
     int BayfrontHeight;
     int BayfrontMarinaHeight;
     int BayfrontGardensHeight;
+    /** Third major fork. */
+    int ClarkeQuayHeight;
     /** Foundation share after AMK, normalized to COIN = 100% */
     CAmount foundationShareDFIP1;
 
diff --git a/src/init.cpp b/src/init.cpp
index 9d10e8c0f3..62f89cc0a6 100644
--- a/src/init.cpp
+++ b/src/init.cpp
@@ -468,6 +468,7 @@ void SetupServerArgs()
     gArgs.AddArg("-amkheight", "AMK fork activation height (regtest only)", ArgsManager::ALLOW_ANY, OptionsCategory::CHAINPARAMS);
     gArgs.AddArg("-bayfrontheight", "Bayfront fork activation height (regtest only)", ArgsManager::ALLOW_ANY, OptionsCategory::CHAINPARAMS);
     gArgs.AddArg("-bayfrontgardensheight", "Bayfront Gardens fork activation height (regtest only)", ArgsManager::ALLOW_ANY, OptionsCategory::CHAINPARAMS);
+    gArgs.AddArg("-clarkequayheight", "ClarkeQuay fork activation height (regtest only)", ArgsManager::ALLOW_ANY, OptionsCategory::CHAINPARAMS);
 #ifdef USE_UPNP
 #if USE_UPNP
     gArgs.AddArg("-upnp", "Use UPnP to map the listening port (default: 1 when listening and no -proxy)", ArgsManager::ALLOW_ANY, OptionsCategory::CONNECTION);
diff --git a/src/masternodes/mn_checks.cpp b/src/masternodes/mn_checks.cpp
index 8197da9f0d..c0e27d41fb 100644
--- a/src/masternodes/mn_checks.cpp
+++ b/src/masternodes/mn_checks.cpp
@@ -1018,9 +1018,16 @@ Res ApplyCreatePoolPairTx(CCustomCSView &mnview, const CCoinsViewCache &coins, c
 
     CPoolPairMessage poolPairMsg;
     std::string pairSymbol;
+    CBalances rewards;
     CDataStream ss(metadata, SER_NETWORK, PROTOCOL_VERSION);
     ss >> poolPairMsg;
     ss >> pairSymbol;
+
+    // Read custom pool rewards
+    if (static_cast<int>(height) >= consensusParams.ClarkeQuayHeight && !ss.empty()) {
+        ss >> rewards;
+    }
+
     if (!ss.empty()) {
         return Res::Err("%s: deserialization failed: excess %d bytes", base,  ss.size());
     }
@@ -1042,12 +1049,12 @@ Res ApplyCreatePoolPairTx(CCustomCSView &mnview, const CCoinsViewCache &coins, c
 
     auto tokenA = mnview.GetToken(poolPairMsg.idTokenA);
     if (!tokenA) {
-        return Res::Err("%s: token %s does not exist!", poolPairMsg.idTokenA.ToString());
+        return Res::Err("%s: token %s does not exist!", base, poolPairMsg.idTokenA.ToString());
     }
 
     auto tokenB = mnview.GetToken(poolPairMsg.idTokenB);
     if (!tokenB) {
-        return Res::Err("%s: token %s does not exist!", poolPairMsg.idTokenB.ToString());
+        return Res::Err("%s: token %s does not exist!", base, poolPairMsg.idTokenB.ToString());
     }
 
     if(pairSymbol.empty())
@@ -1079,6 +1086,20 @@ Res ApplyCreatePoolPairTx(CCustomCSView &mnview, const CCoinsViewCache &coins, c
         rpcInfo->pushKV("tradeable", token.IsTradeable());
         rpcInfo->pushKV("finalized", token.IsFinalized());
 
+        if (!rewards.balances.empty()) {
+            UniValue rewardArr(UniValue::VARR);
+
+            for (const auto& reward : rewards.balances) {
+                if (reward.second > 0) {
+                    rewardArr.push_back(CTokenAmount{reward.first, reward.second}.ToString());
+                }
+            }
+
+            if (!rewardArr.empty()) {
+                rpcInfo->pushKV("customRewards", rewardArr);
+            }
+        }
+
         return Res::Ok(base);
     }
 
@@ -1098,6 +1119,29 @@ Res ApplyCreatePoolPairTx(CCustomCSView &mnview, const CCoinsViewCache &coins, c
         return Res::Err("%s %s: %s", base, pairSymbol, resPP.msg);
     }
 
+    if (!rewards.balances.empty()) {
+        // Check tokens exist and remove empty reward amounts
+        for (auto it = rewards.balances.cbegin(), next_it = it; it != rewards.balances.cend(); it = next_it) {
+            ++next_it;
+
+            auto token = pcustomcsview->GetToken(it->first);
+            if (!token) {
+                return Res::Err("%s: reward token %d does not exist!", base, it->first.v);
+            }
+
+            if (it->second == 0) {
+                rewards.balances.erase(it);
+            }
+        }
+
+        auto resCR = mnview.SetPoolCustomReward(pairToken->first, rewards);
+
+        // Will only fail if pool was not actually created in SetPoolPair
+        if (!resCR.ok) {
+            return Res::Err("%s %s: %s", base, pairSymbol, resCR.msg);
+        }
+    }
+
     return Res::Ok(base);
 }
 
@@ -1113,11 +1157,18 @@ Res ApplyUpdatePoolPairTx(CCustomCSView & mnview, CCoinsViewCache const & coins,
     bool status;
     CAmount commission;
     CScript ownerAddress;
+    CBalances rewards;
     CDataStream ss(metadata, SER_NETWORK, PROTOCOL_VERSION);
     ss >> poolId;
     ss >> status;
     ss >> commission;
     ss >> ownerAddress;
+
+    // Read custom pool rewards
+    if (static_cast<int>(height) >= consensusParams.ClarkeQuayHeight && !ss.empty()) {
+        ss >> rewards;
+    }
+
     if (!ss.empty()) {
         return Res::Err("Pool Update: deserialization failed: excess %d bytes", ss.size());
     }
@@ -1141,6 +1192,56 @@ Res ApplyUpdatePoolPairTx(CCustomCSView & mnview, CCoinsViewCache const & coins,
         rpcInfo->pushKV("commission", ValueFromAmount(commission));
         rpcInfo->pushKV("status", status);
         rpcInfo->pushKV("ownerAddress", ownerAddress.GetHex());
+
+        // Add rewards here before processing them below to avoid adding current rewards
+        if (!rewards.balances.empty()) {
+            UniValue rewardArr(UniValue::VARR);
+
+            // Check for special case to wipe rewards
+            if (rewards.balances.size() == 1 && rewards.balances.cbegin()->first == DCT_ID{std::numeric_limits<uint32_t>::max()}
+                    && rewards.balances.cbegin()->second == std::numeric_limits<CAmount>::max()) {
+                rpcInfo->pushKV("customRewards", rewardArr);
+            } else {
+                for (const auto& reward : rewards.balances) {
+                    if (reward.second > 0) {
+                        rewardArr.push_back(CTokenAmount{reward.first, reward.second}.ToString());
+                    }
+                }
+
+                if (!rewardArr.empty()) {
+                    rpcInfo->pushKV("customRewards", rewardArr);
+                }
+            }
+        }
+    }
+
+    if (!rewards.balances.empty()) {
+        // Check for special case to wipe rewards
+        if (rewards.balances.size() == 1 && rewards.balances.cbegin()->first == DCT_ID{std::numeric_limits<uint32_t>::max()}
+                && rewards.balances.cbegin()->second == std::numeric_limits<CAmount>::max()) {
+            rewards.balances.clear();
+        }
+
+        // Check if tokens exist and remove empty reward amounts
+        for (auto it = rewards.balances.cbegin(), next_it = it; it != rewards.balances.cend(); it = next_it) {
+            ++next_it;
+
+            auto token = pcustomcsview->GetToken(it->first);
+            if (!token) {
+                return Res::Err("%s: reward token %d does not exist!", base, it->first.v);
+            }
+
+            if (it->second == 0) {
+                rewards.balances.erase(it);
+            }
+        }
+
+        auto resCR = mnview.SetPoolCustomReward(poolId, rewards);
+
+        // Will only fail if pool was not actually created in SetPoolPair
+        if (!resCR.ok) {
+            return Res::Err("%s %s: %s", base, poolId.ToString(), resCR.msg);
+        }
     }
 
     return Res::Ok(base);
diff --git a/src/masternodes/mn_rpc.cpp b/src/masternodes/mn_rpc.cpp
index 575fabb119..3163690cb9 100644
--- a/src/masternodes/mn_rpc.cpp
+++ b/src/masternodes/mn_rpc.cpp
@@ -1815,6 +1815,31 @@ UniValue poolToJSON(DCT_ID const& id, CPoolPair const& pool, CToken const& token
 
         poolObj.pushKV("rewardPct", ValueFromAmount(pool.rewardPct));
 
+        auto rewards = pcustomcsview->GetPoolCustomReward(id);
+        if (rewards && !rewards->balances.empty()) {
+            for (auto it = rewards->balances.cbegin(), next_it = it; it != rewards->balances.cend(); it = next_it) {
+                ++next_it;
+
+                // Get token balance
+                const auto balance = pcustomcsview->GetBalance(pool.ownerAddress, it->first).nValue;
+
+                // Make there's enough to pay reward otherwise remove it
+                if (balance < it->second) {
+                    rewards->balances.erase(it);
+                }
+            }
+
+            if (!rewards->balances.empty()) {
+                UniValue rewardArr(UniValue::VARR);
+
+                for (const auto& reward : rewards->balances) {
+                    rewardArr.push_back(CTokenAmount{reward.first, reward.second}.ToString());
+                }
+
+                poolObj.pushKV("customRewards", rewardArr);
+            }
+        }
+
         poolObj.pushKV("creationTx", pool.creationTx.GetHex());
         poolObj.pushKV("creationHeight", (uint64_t) pool.creationHeight);
     }
@@ -2500,6 +2525,8 @@ UniValue createpoolpair(const JSONRPCRequest& request) {
                             "Pool Status: True is Active, False is Restricted"},
                             {"ownerAddress", RPCArg::Type::STR, RPCArg::Optional::NO,
                             "Address of the pool owner."},
+                            {"customRewards", RPCArg::Type::STR, RPCArg::Optional::OMITTED,
+                            "Token reward to be paid on each block, multiple can be specified."},
                             {"pairSymbol", RPCArg::Type::STR, RPCArg::Optional::OMITTED,
                              "Pair symbol (unique), no longer than " +
                              std::to_string(CToken::MAX_TOKEN_SYMBOL_LENGTH)},
@@ -2524,14 +2551,16 @@ UniValue createpoolpair(const JSONRPCRequest& request) {
                                                           "\"tokenB\":\"MyToken2\","
                                                           "\"commission\":\"0.001\","
                                                           "\"status\":\"True\","
-                                                          "\"ownerAddress\":\"Address\""
+                                                          "\"ownerAddress\":\"Address\","
+                                                          "\"customRewards\":\"[\\\"1@tokena\\\",\\\"10@tokenb\\\"]\""
                                                           "}' '[{\"txid\":\"id\",\"vout\":0}]'")
                        + HelpExampleRpc("createpoolpair", "'{\"tokenA\":\"MyToken1\","
                                                           "\"tokenB\":\"MyToken2\","
                                                           "\"commission\":\"0.001\","
                                                           "\"status\":\"True\","
-                                                          "\"ownerAddress\":\"Address\""
-                                                            "}' '[{\"txid\":\"id\",\"vout\":0}]'")
+                                                          "\"ownerAddress\":\"Address\","
+                                                          "\"customRewards\":\"[\\\"1@tokena\\\",\\\"10@tokenb\\\"]\""
+                                                          "}' '[{\"txid\":\"id\",\"vout\":0}]'")
                },
     }.Check(request);
 
@@ -2546,6 +2575,7 @@ UniValue createpoolpair(const JSONRPCRequest& request) {
     std::string tokenA, tokenB, pairSymbol;
     CAmount commission = 0; // !!!
     CScript ownerAddress;
+    CBalances rewards;
     bool status = true; // default Active
     UniValue metadataObj = request.params[0].get_obj();
     if (!metadataObj["tokenA"].isNull()) {
@@ -2566,6 +2596,9 @@ UniValue createpoolpair(const JSONRPCRequest& request) {
     if (!metadataObj["pairSymbol"].isNull()) {
         pairSymbol = metadataObj["pairSymbol"].getValStr();
     }
+    if (!metadataObj["customRewards"].isNull()) {
+        rewards = DecodeAmounts(pwallet->chain(), metadataObj["customRewards"], "");
+    }
 
     int targetHeight;
     DCT_ID idtokenA, idtokenB;
@@ -2594,6 +2627,10 @@ UniValue createpoolpair(const JSONRPCRequest& request) {
     metadata << static_cast<unsigned char>(CustomTxType::CreatePoolPair)
              << poolPairMsg << pairSymbol;
 
+    if (targetHeight >= Params().GetConsensus().ClarkeQuayHeight) {
+        metadata << rewards;
+    }
+
     CScript scriptMeta;
     scriptMeta << OP_RETURN << ToByteVector(metadata);
 
@@ -2648,7 +2685,7 @@ UniValue updatepoolpair(const JSONRPCRequest& request) {
                            {"status", RPCArg::Type::BOOL, RPCArg::Optional::OMITTED, "Pool Status new property (bool)"},
                            {"commission", RPCArg::Type::NUM, RPCArg::Optional::OMITTED, "Pool commission, up to 10^-8"},
                            {"ownerAddress", RPCArg::Type::STR, RPCArg::Optional::OMITTED, "Address of the pool owner."},
-
+                           {"customRewards", RPCArg::Type::STR, RPCArg::Optional::OMITTED, "Token reward to be paid on each block, multiple can be specified."},
                        },
                    },
                    {"inputs", RPCArg::Type::ARR, RPCArg::Optional::OMITTED_NAMED_ARG, "A json array of json objects",
@@ -2668,10 +2705,12 @@ UniValue updatepoolpair(const JSONRPCRequest& request) {
                },
                RPCExamples{
                        HelpExampleCli("updatepoolpair", "'{\"pool\":\"POOL\",\"status\":true,"
-                                                     "\"commission\":0.01,\"ownerAddress\":\"Address\"}' "
+                                                     "\"commission\":0.01,\"ownerAddress\":\"Address\","
+                                                     "\"customRewards\":\"[\\\"1@tokena\\\",\\\"10@tokenb\\\"]\"}' "
                                                      "'[{\"txid\":\"id\",\"vout\":0}]'")
                        + HelpExampleRpc("updatepoolpair", "'{\"pool\":\"POOL\",\"status\":true,"
-                                                       "\"commission\":0.01,\"ownerAddress\":\"Address\"}' "
+                                                       "\"commission\":0.01,\"ownerAddress\":\"Address\","
+                                                       "\"customRewards\":\"[\\\"1@tokena\\\",\\\"10@tokenb\\\"]\"}' "
                                                        "'[{\"txid\":\"id\",\"vout\":0}]'")
                },
     }.Check(request);
@@ -2688,6 +2727,7 @@ UniValue updatepoolpair(const JSONRPCRequest& request) {
     bool status = true;
     CAmount commission = -1;
     CScript ownerAddress;
+    CBalances rewards;
     UniValue const & metaObj = request.params[0].get_obj();
     UniValue const & txInputs = request.params[1];
 
@@ -2718,6 +2758,14 @@ UniValue updatepoolpair(const JSONRPCRequest& request) {
     if (!metaObj["ownerAddress"].isNull()) {
         ownerAddress = DecodeScript(metaObj["ownerAddress"].getValStr());
     }
+    if (!metaObj["customRewards"].isNull()) {
+        rewards = DecodeAmounts(pwallet->chain(), metaObj["customRewards"], "");
+
+        if (rewards.balances.empty()) {
+            // Add special case to wipe rewards
+            rewards.balances.insert(std::pair<DCT_ID, CAmount>(DCT_ID{std::numeric_limits<uint32_t>::max()}, std::numeric_limits<CAmount>::max()));
+        }
+    }
 
     const auto txVersion = GetTransactionVersion(targetHeight);
     CMutableTransaction rawTx(txVersion);
@@ -2730,6 +2778,10 @@ UniValue updatepoolpair(const JSONRPCRequest& request) {
     metadata << static_cast<unsigned char>(CustomTxType::UpdatePoolPair)
              << poolId << status << commission << ownerAddress;
 
+    if (targetHeight >= Params().GetConsensus().ClarkeQuayHeight) {
+        metadata << rewards;
+    }
+
     CScript scriptMeta;
     scriptMeta << OP_RETURN << ToByteVector(metadata);
 
diff --git a/src/masternodes/poolpairs.cpp b/src/masternodes/poolpairs.cpp
index 2f20a46d0c..2080de7f52 100644
--- a/src/masternodes/poolpairs.cpp
+++ b/src/masternodes/poolpairs.cpp
@@ -10,6 +10,7 @@
 const unsigned char CPoolPairView::ByID          ::prefix = 'i';
 const unsigned char CPoolPairView::ByPair        ::prefix = 'j';
 const unsigned char CPoolPairView::ByShare       ::prefix = 'k';
+const unsigned char CPoolPairView::Reward        ::prefix = 'I';
 
 Res CPoolPairView::SetPoolPair(DCT_ID const & poolId, CPoolPair const & pool)
 {
@@ -98,6 +99,24 @@ boost::optional<std::pair<DCT_ID, CPoolPair> > CPoolPairView::GetPoolPair(const
     return {};
 }
 
+Res CPoolPairView::SetPoolCustomReward(const DCT_ID &poolId, CBalances& rewards)
+{
+    DCT_ID poolID = poolId;
+    if (!GetPoolPair(poolID))
+    {
+        return Res::Err("Error %s: poolID %s does not exist", __func__, poolID.ToString());
+    }
+
+    WriteBy<Reward>(WrapVarInt(poolID.v), rewards);
+    return Res::Ok();
+}
+
+boost::optional<CBalances> CPoolPairView::GetPoolCustomReward(const DCT_ID &poolId)
+{
+    DCT_ID poolID = poolId;
+    return ReadBy<Reward, CBalances>(WrapVarInt(poolID.v));
+}
+
 Res CPoolPair::Swap(CTokenAmount in, PoolPrice const & maxPrice, std::function<Res (const CTokenAmount &tokenAmount)> onTransfer, bool postBayfrontGardens) {
     if (in.nTokenId != idTokenA && in.nTokenId != idTokenB) {
         throw std::runtime_error("Error, input token ID (" + in.nTokenId.ToString() + ") doesn't match pool tokens (" + idTokenA.ToString() + "," + idTokenB.ToString() + ")");
diff --git a/src/masternodes/poolpairs.h b/src/masternodes/poolpairs.h
index 3a94902a01..f7bb803574 100644
--- a/src/masternodes/poolpairs.h
+++ b/src/masternodes/poolpairs.h
@@ -9,6 +9,7 @@
 
 #include <amount.h>
 #include <arith_uint256.h>
+#include <chainparams.h>
 #include <masternodes/res.h>
 #include <script/script.h>
 #include <serialize.h>
@@ -250,7 +251,9 @@ class CPoolPairView : public virtual CStorageView
 public:
     Res SetPoolPair(const DCT_ID &poolId, CPoolPair const & pool);
     Res UpdatePoolPair(DCT_ID const & poolId, bool & status, CAmount const & commission, CScript const & ownerAddress);
-    Res DeletePoolPair(DCT_ID const & poolId);
+
+    Res SetPoolCustomReward(const DCT_ID &poolId, CBalances &rewards);
+    boost::optional<CBalances> GetPoolCustomReward(const DCT_ID &poolId);
 
     boost::optional<CPoolPair> GetPoolPair(const DCT_ID &poolId) const;
     boost::optional<std::pair<DCT_ID, CPoolPair> > GetPoolPair(DCT_ID const & tokenA, DCT_ID const & tokenB) const;
@@ -268,7 +271,9 @@ class CPoolPairView : public virtual CStorageView
     }
 
     /// @attention it throws (at least for debug), cause errors are critical!
-    CAmount DistributeRewards(CAmount yieldFarming, std::function<CTokenAmount(CScript const & owner, DCT_ID tokenID)> onGetBalance, std::function<Res(CScript const & to, DCT_ID poolID, uint8_t type, CTokenAmount amount)> onTransfer, bool newRewardCalc = false) {
+    CAmount DistributeRewards(CAmount yieldFarming, std::function<CTokenAmount(CScript const & owner, DCT_ID tokenID)> onGetBalance, std::function<Res(CScript const & to, CScript const & from, DCT_ID poolID, uint8_t type, CTokenAmount amount)> onTransfer, int nHeight = 0) {
+
+        bool newRewardCalc = nHeight >= Params().GetConsensus().BayfrontGardensHeight;
 
         uint32_t const PRECISION = 10000; // (== 100%) just searching the way to avoid arith256 inflating
         CAmount totalDistributed = 0;
@@ -280,7 +285,28 @@ class CPoolPairView : public virtual CStorageView
             CAmount distributedFeeA = 0;
             CAmount distributedFeeB = 0;
 
-            if (pool.totalLiquidity == 0 || (!pool.swapEvent && poolReward == 0)) {
+            auto rewards = GetPoolCustomReward(poolId);
+            bool payCustomRewards{false};
+
+            if (nHeight >= Params().GetConsensus().ClarkeQuayHeight && rewards && !rewards->balances.empty()) {
+                for (auto it = rewards->balances.cbegin(), next_it = it; it != rewards->balances.cend(); it = next_it) {
+                    ++next_it;
+
+                    // Get token balance
+                    const auto balance = onGetBalance(pool.ownerAddress, it->first).nValue;
+
+                    // Make there's enough to pay reward otherwise remove it
+                    if (balance < it->second) {
+                        rewards->balances.erase(it);
+                    }
+                }
+
+                if (!rewards->balances.empty()) {
+                    payCustomRewards = true;
+                }
+            }
+
+            if (pool.totalLiquidity == 0 || (!pool.swapEvent && poolReward == 0 && !payCustomRewards)) {
                 return true; // no events, skip to the next pool
             }
 
@@ -300,13 +326,13 @@ class CPoolPairView : public virtual CStorageView
                         feeA = pool.blockCommissionA * liqWeight / PRECISION;
                     }
                     distributedFeeA += feeA;
-                    onTransfer(provider, poolId, uint8_t(RewardType::Commission), {pool.idTokenA, feeA}); //can throw
+                    onTransfer(provider, CScript(), poolId, uint8_t(RewardType::Commission), {pool.idTokenA, feeA}); //can throw
                     CAmount feeB = static_cast<CAmount>((arith_uint256(pool.blockCommissionB) * arith_uint256(liquidity) / arith_uint256(pool.totalLiquidity)).GetLow64());
                     if (!newRewardCalc) {
                         feeB = pool.blockCommissionB * liqWeight / PRECISION;
                     }
                     distributedFeeB += feeB;
-                    onTransfer(provider, poolId, uint8_t(RewardType::Commission), {pool.idTokenB, feeB}); //can throw
+                    onTransfer(provider, CScript(), poolId, uint8_t(RewardType::Commission), {pool.idTokenB, feeB}); //can throw
                 }
 
                 // distribute yield farming
@@ -316,10 +342,22 @@ class CPoolPairView : public virtual CStorageView
                         providerReward = poolReward * liqWeight / PRECISION;
                     }
                     if (providerReward) {
-                        onTransfer(provider, poolId, uint8_t(RewardType::Rewards), {DCT_ID{0}, providerReward}); //can throw
+                        onTransfer(provider, CScript(), poolId, uint8_t(RewardType::Rewards), {DCT_ID{0}, providerReward}); //can throw
                         totalDistributed += providerReward;
                     }
                 }
+
+                // Distribute custom rewards
+                if (payCustomRewards) {
+                    for (const auto reward : rewards->balances) {
+                        CAmount providerReward = static_cast<CAmount>((arith_uint256(reward.second) * arith_uint256(liquidity) / arith_uint256(pool.totalLiquidity)).GetLow64());
+
+                        if (providerReward) {
+                            onTransfer(provider, pool.ownerAddress, poolId, uint8_t(RewardType::Rewards), {reward.first, providerReward}); //can throw
+                        }
+                    }
+                }
+
                 return true;
             }, PoolShareKey{poolId, CScript{}});
 
@@ -340,6 +378,7 @@ class CPoolPairView : public virtual CStorageView
     struct ByID { static const unsigned char prefix; }; // lsTokenID -> СPoolPair
     struct ByPair { static const unsigned char prefix; }; // tokenA+tokenB -> lsTokenID
     struct ByShare { static const unsigned char prefix; }; // lsTokenID+accountID -> {}
+    struct Reward { static const unsigned char prefix; }; // lsTokenID -> CBalances
 };
 
 struct CLiquidityMessage {
diff --git a/src/rpc/blockchain.cpp b/src/rpc/blockchain.cpp
index 4d6d02ebe3..e3b87fde20 100644
--- a/src/rpc/blockchain.cpp
+++ b/src/rpc/blockchain.cpp
@@ -1312,6 +1312,7 @@ UniValue getblockchaininfo(const JSONRPCRequest& request)
     BuriedForkDescPushBack(softforks, "segwit", consensusParams.SegwitHeight);
     BuriedForkDescPushBack(softforks, "amk", consensusParams.AMKHeight);
     BuriedForkDescPushBack(softforks, "bayfront", consensusParams.BayfrontHeight);
+    BuriedForkDescPushBack(softforks, "clarkequay", consensusParams.ClarkeQuayHeight);
     BIP9SoftForkDescPushBack(softforks, "testdummy", consensusParams, Consensus::DEPLOYMENT_TESTDUMMY);
     obj.pushKV("softforks",             softforks);
 
diff --git a/src/test/liquidity_tests.cpp b/src/test/liquidity_tests.cpp
index c7a4f7c81c..98e2b1e831 100644
--- a/src/test/liquidity_tests.cpp
+++ b/src/test/liquidity_tests.cpp
@@ -315,7 +315,7 @@ BOOST_AUTO_TEST_CASE(math_rewards)
             [&cache] (CScript const & owner, DCT_ID tokenID) {
                 return cache.GetBalance(owner, tokenID);
             },
-            [&cache] (CScript const & to, DCT_ID poolID, uint8_t type, CTokenAmount amount) {
+            [&cache] (CScript const & to, CScript const & from, DCT_ID poolID, uint8_t type, CTokenAmount amount) {
                 return cache.AddBalance(to, amount);
             }
         );
diff --git a/src/validation.cpp b/src/validation.cpp
index 9224651b46..085456ba80 100644
--- a/src/validation.cpp
+++ b/src/validation.cpp
@@ -2304,18 +2304,24 @@ bool CChainState::ConnectBlock(const CBlock& block, CValidationState& state, CBl
                 [&cache] (CScript const & owner, DCT_ID tokenID) {
                     return cache.GetBalance(owner, tokenID);
                 },
-                [&cache, &block] (CScript const & to, DCT_ID poolID, uint8_t type, CTokenAmount amount) {
+                [&cache, &block] (CScript const & to, CScript const & from, DCT_ID poolID, uint8_t type, CTokenAmount amount) {
+                    if (from != CScript()) {
+                        auto res = cache.SubBalance(from, amount);
+                        if (!res.ok) {
+                            throw std::runtime_error(strprintf("Custom pool rewards: can't update balance of %s: %s, Block %ld (%s)", to.GetHex(), res.msg, block.height, block.GetHash().ToString()));
+                        }
+                    }
                     auto res = cache.AddBalance(to, poolID, type, amount);
                     if (!res.ok)
                         throw std::runtime_error(strprintf("Pool rewards: can't update balance of %s: %s, Block %ld (%s)", to.GetHex(), res.msg, block.height, block.GetHash().ToString()));
                     return res;
                 },
-                pindex->nHeight >= chainparams.GetConsensus().BayfrontGardensHeight // Toggle new reward calc behaviour
+                pindex->nHeight
             );
 
             auto res = cache.SubCommunityBalance(CommunityAccountType::IncentiveFunding, distributed);
             if (!res.ok)
-                throw std::runtime_error(strprintf("Pool rewards: can't update community balance: %s. Block %ld (%s)", res.msg, block.height, block.GetHash().ToString()));
+                LogPrintf("Pool rewards: can't update community balance: %s. Block %ld (%s)\n", res.msg, block.height, block.GetHash().ToString());
         }
         // Remove `Finalized` and/or `LPS` flags _possibly_set_ by bytecoded (cheated) txs before bayfront fork
         if (pindex->nHeight == chainparams.GetConsensus().BayfrontHeight - 1) { // call at block _before_ fork
diff --git a/test/functional/feature_custom_poolreward.py b/test/functional/feature_custom_poolreward.py
new file mode 100644
index 0000000000..a935d9556b
--- /dev/null
+++ b/test/functional/feature_custom_poolreward.py
@@ -0,0 +1,336 @@
+#!/usr/bin/env python3
+# Copyright (c) 2014-2019 The Bitcoin Core developers
+# Copyright (c) DeFi Blockchain Developers
+# Distributed under the MIT software license, see the accompanying
+# file COPYING or http://www.opensource.org/licenses/mit-license.php.
+"""Test custom pool reward."""
+
+from test_framework.test_framework import DefiTestFramework
+
+from test_framework.util import assert_equal
+from test_framework.authproxy import JSONRPCException
+
+class TokensCustomPoolReward(DefiTestFramework):
+    def set_test_params(self):
+        self.num_nodes = 2
+        self.setup_clean_chain = True
+        self.extra_args = [['-txnotokens=0', '-amkheight=50', '-bayfrontheight=50', '-bayfrontgardensheight=50', '-clarkequayheight=50'],
+                           ['-txnotokens=0', '-amkheight=50', '-bayfrontheight=50', '-bayfrontgardensheight=50', '-clarkequayheight=50']]
+
+    def run_test(self):
+        self.nodes[0].generate(102)
+        num_tokens = len(self.nodes[0].listtokens())
+
+        # collateral addresses
+        collateral_a = self.nodes[0].getnewaddress("", "legacy")
+        collateral_b = self.nodes[0].getnewaddress("", "legacy")
+
+        # Create token
+        self.nodes[0].createtoken({
+            "symbol": "GOLD",
+            "name": "gold",
+            "collateralAddress": collateral_a
+        })
+        self.nodes[0].generate(1)
+
+        # Create token
+        self.nodes[0].createtoken({
+            "symbol": "SILVER",
+            "name": "silver",
+            "collateralAddress": collateral_b
+        })
+        self.nodes[0].generate(1)
+
+        # Get token ID
+        list_tokens = self.nodes[0].listtokens()
+        for idx, token in list_tokens.items():
+            if (token["symbol"] == "GOLD"):
+                token_a = idx
+            if (token["symbol"] == "SILVER"):
+                token_b = idx
+
+        # Make sure there's an extra token
+        assert_equal(len(self.nodes[0].listtokens()), num_tokens + 2)
+
+        # Mint some tokens
+        self.nodes[0].minttokens(["100000@" + token_a])
+        self.nodes[0].minttokens(["100000@" + token_b])
+        self.nodes[0].generate(1)
+
+        # Create pool collateral address
+        pool_collateral = self.nodes[0].getnewaddress("", "legacy")
+
+        # Fail on zero amount token reward
+        try:
+            self.nodes[0].createpoolpair({
+            "tokenA": "GOLD#" + token_a,
+            "tokenB": "SILVER#" + token_b,
+            "commission": 0.001,
+            "status": True,
+            "ownerAddress": pool_collateral,
+            "pairSymbol": "SILVGOLD",
+            "customRewards": ["0@" + token_a]
+        })
+        except JSONRPCException as e:
+            errorString = e.error['message']
+        assert("Amount out of range" in errorString)
+        errorString = ""
+
+        # Fail on token that does not exist
+        try:
+            self.nodes[0].createpoolpair({
+            "tokenA": "GOLD#" + token_a,
+            "tokenB": "SILVER#" + token_b,
+            "commission": 0.001,
+            "status": True,
+            "ownerAddress": pool_collateral,
+            "pairSymbol": "SILVGOLD",
+            "customRewards": ["1@100"]
+        })
+        except JSONRPCException as e:
+            errorString = e.error['message']
+        assert("reward token 100 does not exist" in errorString)
+        errorString = ""
+
+        # Create pool with token rewards
+        poolpair_tx = self.nodes[0].createpoolpair({
+            "tokenA": "GOLD#" + token_a,
+            "tokenB": "SILVER#" + token_b,
+            "commission": 0.001,
+            "status": True,
+            "ownerAddress": pool_collateral,
+            "pairSymbol": "SILVGOLD",
+            "customRewards": ["1@" + token_a, "1@" + token_b]
+        })
+        self.nodes[0].generate(1)
+
+        # Check that customReards shows up in getcustomtx
+        result = self.nodes[0].getcustomtx(poolpair_tx)
+        assert_equal(result['results']['customRewards'], ["1.00000000@" + token_a, "1.00000000@" + token_b])
+
+        # custom rewards should not show up yet without balance
+        assert('customRewards' not in self.nodes[0].getpoolpair(1)['1'])
+
+        # Create and fund liquidity provider
+        provider = self.nodes[1].getnewaddress("", "legacy")
+
+        # Add pool liqudity
+        self.nodes[0].addpoolliquidity({
+            "*": ["1@" + token_a, "1@" + token_b]
+        }, provider)
+        self.nodes[0].generate(1)
+
+        # Provide pool reward for token a
+        self.nodes[0].accounttoaccount(collateral_a, {pool_collateral: "1@" + token_a})
+        self.nodes[0].generate(1)
+
+        # token a reward should be added to provider
+        assert_equal(self.nodes[1].getaccount(provider), ['0.99999000@SILVGOLD', '0.99999000@GOLD#128'])
+
+        # Make sure amount reduced from token a
+        assert_equal(self.nodes[1].getaccount(pool_collateral), ['0.00001000@GOLD#128'])
+        self.nodes[0].generate(1)
+
+        # token a amount should be static as not enough funds to pay
+        assert_equal(self.nodes[1].getaccount(provider), ['0.99999000@SILVGOLD', '0.99999000@GOLD#128'])
+
+        # Provide pool reward for token b
+        self.nodes[0].accounttoaccount(collateral_b, {pool_collateral: "1@" + token_b})
+        self.nodes[0].generate(1)
+
+        # token b reward should be added to provider but token a same as before
+        assert_equal(self.nodes[1].getaccount(provider), ['0.99999000@SILVGOLD', '0.99999000@GOLD#128', '0.99999000@SILVER#129'])
+
+        # Make sure amount reduced from token a
+        assert_equal(self.nodes[1].getaccount(pool_collateral), ['0.00001000@GOLD#128', '0.00001000@SILVER#129'])
+        self.nodes[0].generate(1)
+
+        # token a and b amount should be static as not enough funds to pay
+        assert_equal(self.nodes[1].getaccount(provider), ['0.99999000@SILVGOLD', '0.99999000@GOLD#128', '0.99999000@SILVER#129'])
+
+        # Fund addresses to avoid auto auth to send raw via node 1 easily
+        self.nodes[0].sendtoaddress(collateral_a, 1)
+        self.nodes[0].sendtoaddress(collateral_b, 1)
+        self.nodes[0].generate(1)
+
+        # Provide pool reward for token a and b
+        tx1 = self.nodes[0].accounttoaccount(collateral_a, {pool_collateral: "10@" + token_a})
+        tx2 = self.nodes[0].accounttoaccount(collateral_b, {pool_collateral: "10@" + token_b})
+
+        # Send raw on second node to make sure that it is present in mempool
+        rawtx1 = self.nodes[0].getrawtransaction(tx1)
+        rawtx2 = self.nodes[0].getrawtransaction(tx2)
+        self.nodes[1].sendrawtransaction(rawtx1)
+        self.nodes[1].sendrawtransaction(rawtx2)
+
+        # Generate block and trigger potential payouts
+        self.nodes[1].generate(1)
+        self.sync_blocks()
+
+        # Both token a and b should be present
+        assert_equal(self.nodes[1].getpoolpair(1)['1']['customRewards'], ['1.00000000@128', '1.00000000@129'])
+        assert_equal(self.nodes[0].getpoolpair(1)['1']['customRewards'], ['1.00000000@128', '1.00000000@129'])
+
+        # Generate 9 more blocks and trigger potential payouts
+        self.nodes[1].generate(9)
+
+        # token a and b rewards should be added to provider
+        assert_equal(self.nodes[1].getaccount(provider), ['0.99999000@SILVGOLD', '10.99989000@GOLD#128', '10.99989000@SILVER#129'])
+
+        # Make sure amount reduced from token a
+        assert_equal(self.nodes[1].getaccount(pool_collateral), ['0.00011000@GOLD#128', '0.00011000@SILVER#129'])
+
+        # custom rewards should not show up yet without balance
+        assert('customRewards' not in self.nodes[0].getpoolpair(1)['1'])
+
+        # Top up of token a to test poolpair output
+        self.nodes[0].accounttoaccount(collateral_a, {pool_collateral: "10@" + token_a})
+        self.nodes[0].generate(1)
+
+        # Check only token a reward shows
+        assert_equal(self.nodes[0].getpoolpair(1)['1']['customRewards'], ['1.00000000@128'])
+
+        # Generate another block and trigger potential payout
+        self.nodes[0].generate(9)
+
+        # custom rewards should not show up yet without balance
+        assert('customRewards' not in self.nodes[0].getpoolpair(1)['1'])
+
+        # Top up of token b to test poolpair output
+        self.nodes[0].accounttoaccount(collateral_b, {pool_collateral: "10@" + token_b})
+        self.nodes[0].generate(1)
+
+        # Check only token a reward shows
+        assert_equal(self.nodes[0].getpoolpair(1)['1']['customRewards'], ['1.00000000@129'])
+
+        # Generate another block and trigger potential payout
+        self.nodes[0].generate(9)
+
+        # custom rewards should not show up yet without balance
+        assert('customRewards' not in self.nodes[0].getpoolpair(1)['1'])
+
+        # Create new token for reward
+        num_tokens = len(self.nodes[0].listtokens())
+        collateral_c = self.nodes[0].getnewaddress("", "legacy")
+        self.nodes[0].createtoken({
+            "symbol": "BRONZE",
+            "name": "bronze",
+            "collateralAddress": collateral_c
+        })
+        self.nodes[0].generate(1)
+
+        # Get token ID
+        list_tokens = self.nodes[0].listtokens()
+        for idx, token in list_tokens.items():
+            if (token["symbol"] == "BRONZE"):
+                token_c = idx
+
+        # Make sure there's an extra token
+        assert_equal(len(self.nodes[0].listtokens()), num_tokens + 1)
+
+        # Mint some tokens
+        self.nodes[0].minttokens(["100000@" + token_c])
+        self.nodes[0].generate(1)
+
+        # Top up of token c to test poolpair output before adding it to he pool
+        self.nodes[0].accounttoaccount(collateral_c, {pool_collateral: "10@" + token_c})
+        self.nodes[0].generate(1)
+
+        # Fail on zero amount token reward
+        try:
+            self.nodes[0].updatepoolpair({"pool": "1", "customRewards": ["0@" + token_c]})
+        except JSONRPCException as e:
+            errorString = e.error['message']
+        assert("Amount out of range" in errorString)
+        errorString = ""
+
+        # Update poolpair with invalid reward token
+        try:
+            self.nodes[0].updatepoolpair({"pool": "1", "customRewards": ["1@100"]})
+        except JSONRPCException as e:
+            errorString = e.error['message']
+        assert("reward token 100 does not exist" in errorString)
+        errorString = ""
+
+        # Replace tokens with token c
+        updatepoolpair_tx = self.nodes[0].updatepoolpair({"pool": "1", "customRewards": ["1@" + token_c]})
+        self.nodes[0].generate(1)
+
+        # Check that customReards shows up in getcustomtx
+        result = self.nodes[0].getcustomtx(updatepoolpair_tx)
+        assert_equal(result['results']['customRewards'], ["1.00000000@" + token_c])
+
+        # Check for new block reward and payout
+        assert_equal(self.nodes[1].getpoolpair(1)['1']['customRewards'], ['1.00000000@130'])
+        assert_equal(self.nodes[1].getaccount(provider), ['0.99999000@SILVGOLD', '20.99979000@GOLD#128', '20.99979000@SILVER#129', '0.99999000@BRONZE#130'])
+        assert_equal(self.nodes[1].getaccount(pool_collateral), ['0.00021000@GOLD#128', '0.00021000@SILVER#129', '9.00001000@BRONZE#130'])
+
+        # Provide pool reward for token a, should not show as it wasd removed
+        self.nodes[0].accounttoaccount(collateral_a, {pool_collateral: "10@" + token_a})
+        self.nodes[0].generate(1)
+
+        # Check for new block reward and payout
+        assert_equal(self.nodes[1].getpoolpair(1)['1']['customRewards'], ['1.00000000@130'])
+        assert_equal(self.nodes[1].getaccount(provider), ['0.99999000@SILVGOLD', '20.99979000@GOLD#128', '20.99979000@SILVER#129', '1.99998000@BRONZE#130'])
+        assert_equal(self.nodes[1].getaccount(pool_collateral), ['10.00021000@GOLD#128', '0.00021000@SILVER#129', '8.00002000@BRONZE#130'])
+
+        # Add back token a
+        updatepoolpair_tx = self.nodes[0].updatepoolpair({"pool": "1", "customRewards": ["1@" + token_a, "1@" + token_c]})
+        self.nodes[0].generate(1)
+
+        # Check that customReards shows up in getcustomtx
+        result = self.nodes[0].getcustomtx(updatepoolpair_tx)
+        assert_equal(result['results']['customRewards'], ["1.00000000@" + token_a, "1.00000000@" + token_c])
+
+        # Check for new block reward and payout for token a and c
+        assert_equal(self.nodes[1].getpoolpair(1)['1']['customRewards'], ['1.00000000@128', '1.00000000@130'])
+        assert_equal(self.nodes[1].getaccount(provider), ['0.99999000@SILVGOLD', '21.99978000@GOLD#128', '20.99979000@SILVER#129', '2.99997000@BRONZE#130'])
+        assert_equal(self.nodes[1].getaccount(pool_collateral), ['9.00022000@GOLD#128', '0.00021000@SILVER#129', '7.00003000@BRONZE#130'])
+
+        # Provide pool reward for token b, should not show as it was removed
+        self.nodes[0].accounttoaccount(collateral_b, {pool_collateral: "10@" + token_b})
+        self.nodes[0].generate(1)
+
+        # Check for new block reward and payout
+        assert_equal(self.nodes[1].getpoolpair(1)['1']['customRewards'], ['1.00000000@128', '1.00000000@130'])
+        assert_equal(self.nodes[1].getaccount(provider), ['0.99999000@SILVGOLD', '22.99977000@GOLD#128', '20.99979000@SILVER#129', '3.99996000@BRONZE#130'])
+        assert_equal(self.nodes[1].getaccount(pool_collateral), ['8.00023000@GOLD#128', '10.00021000@SILVER#129', '6.00004000@BRONZE#130'])
+
+        # Add back token b
+        updatepoolpair_tx = self.nodes[0].updatepoolpair({"pool": "1", "customRewards": ["1@" + token_a, "1@" + token_b, "1@" + token_c]})
+        self.nodes[0].generate(1)
+
+        # Check that customReards shows up in getcustomtx
+        result = self.nodes[0].getcustomtx(updatepoolpair_tx)
+        assert_equal(result['results']['customRewards'], ["1.00000000@" + token_a, "1.00000000@" + token_b, "1.00000000@" + token_c])
+
+        # Check for new block reward and payout for token a, b and c
+        assert_equal(self.nodes[1].getpoolpair(1)['1']['customRewards'], ['1.00000000@128', '1.00000000@129', '1.00000000@130'])
+        assert_equal(self.nodes[1].getaccount(provider), ['0.99999000@SILVGOLD', '23.99976000@GOLD#128', '21.99978000@SILVER#129', '4.99995000@BRONZE#130'])
+        assert_equal(self.nodes[1].getaccount(pool_collateral), ['7.00024000@GOLD#128', '9.00022000@SILVER#129', '5.00005000@BRONZE#130'])
+
+        # Do nothing
+        updatepoolpair_tx = self.nodes[0].updatepoolpair({"pool": "1"})
+        self.nodes[0].generate(1)
+
+        # Check that customReards shows up in getcustomtx
+        result = self.nodes[0].getcustomtx(updatepoolpair_tx)
+        assert('customRewards' not in result['results'])
+
+        # Check for new block reward and payout for token a, b and c
+        assert_equal(self.nodes[1].getpoolpair(1)['1']['customRewards'], ['1.00000000@128', '1.00000000@129', '1.00000000@130'])
+        assert_equal(self.nodes[1].getaccount(provider), ['0.99999000@SILVGOLD', '24.99975000@GOLD#128', '22.99977000@SILVER#129', '5.99994000@BRONZE#130'])
+        assert_equal(self.nodes[1].getaccount(pool_collateral), ['6.00025000@GOLD#128', '8.00023000@SILVER#129', '4.00006000@BRONZE#130'])
+
+        # Wipe all rewards
+        updatepoolpair_tx = self.nodes[0].updatepoolpair({"pool": "1", "customRewards": []})
+        self.nodes[0].generate(1)
+
+        # Check TX shows rewards present and empty and balances should be unchanged
+        result = self.nodes[0].getcustomtx(updatepoolpair_tx)
+        assert_equal(result['results']['customRewards'], [])
+        assert_equal(self.nodes[1].getaccount(provider), ['0.99999000@SILVGOLD', '24.99975000@GOLD#128', '22.99977000@SILVER#129', '5.99994000@BRONZE#130'])
+        assert_equal(self.nodes[1].getaccount(pool_collateral), ['6.00025000@GOLD#128', '8.00023000@SILVER#129', '4.00006000@BRONZE#130'])
+
+if __name__ == '__main__':
+    TokensCustomPoolReward().main()
diff --git a/test/functional/rpc_blockchain.py b/test/functional/rpc_blockchain.py
index a04e8cb40a..b8ebd78fd3 100755
--- a/test/functional/rpc_blockchain.py
+++ b/test/functional/rpc_blockchain.py
@@ -131,6 +131,7 @@ def _test_getblockchaininfo(self):
             'segwit': {'type': 'buried', 'active': True, 'height': 0},
             'amk': {'type': 'buried', 'active': False, 'height': 10000000},
             'bayfront': {'type': 'buried', 'active': False, 'height': 10000000},
+            'clarkequay': {'type': 'buried', 'active': False, 'height': 10000000},
             'testdummy': {
                 'type': 'bip9',
                 'bip9': {
diff --git a/test/functional/test_runner.py b/test/functional/test_runner.py
index 308d7f00c9..fca0389e9d 100755
--- a/test/functional/test_runner.py
+++ b/test/functional/test_runner.py
@@ -212,6 +212,7 @@
     'feature_cltv.py',
     'rpc_uptime.py',
     'wallet_resendwallettransactions.py',
+    'feature_custom_poolreward.py',
     'wallet_fallbackfee.py',
     'feature_minchainwork.py',
     'rpc_getblockstats.py',