diff --git a/src/CMakeLists.txt b/src/CMakeLists.txt
--- a/src/CMakeLists.txt
+++ b/src/CMakeLists.txt
@@ -503,6 +503,7 @@
 	interfaces/chain.cpp
 	interfaces/node.cpp
 	miner.cpp
+	minerfund.cpp
 	net.cpp
 	net_processing.cpp
 	node/coin.cpp
diff --git a/src/Makefile.am b/src/Makefile.am
--- a/src/Makefile.am
+++ b/src/Makefile.am
@@ -181,6 +181,7 @@
   memusage.h \
   merkleblock.h \
   miner.h \
+  minerfund.h \
   net.h \
   net_permissions.h \
   net_processing.h \
@@ -328,6 +329,7 @@
   interfaces/node.cpp \
   dbwrapper.cpp \
   miner.cpp \
+  minerfund.cpp \
   net.cpp \
   net_processing.cpp \
   node/coin.cpp \
diff --git a/src/chainparams.cpp b/src/chainparams.cpp
--- a/src/chainparams.cpp
+++ b/src/chainparams.cpp
@@ -112,6 +112,9 @@
             .nTimeout = 1230767999,
         };
 
+        // The miner fund is enabled by default on mainnet.
+        consensus.enableMinerFund = true;
+
         // The best chain should have at least this much work.
         consensus.nMinimumChainWork =
             ChainParamsConstants::MAINNET_MINIMUM_CHAIN_WORK;
@@ -313,6 +316,9 @@
             .nTimeout = 1230767999,
         };
 
+        // The miner fund is disabled by default on testnet.
+        consensus.enableMinerFund = false;
+
         // The best chain should have at least this much work.
         consensus.nMinimumChainWork =
             ChainParamsConstants::TESTNET_MINIMUM_CHAIN_WORK;
@@ -465,6 +471,9 @@
             .nActivationThreshold = 108,
         };
 
+        // The miner fund is disabled by default on regnet.
+        consensus.enableMinerFund = false;
+
         // The best chain should have at least this much work.
         consensus.nMinimumChainWork = uint256S("0x00");
 
diff --git a/src/consensus/params.h b/src/consensus/params.h
--- a/src/consensus/params.h
+++ b/src/consensus/params.h
@@ -93,6 +93,9 @@
     uint32_t nMinerConfirmationWindow;
     BIP9Deployment vDeployments[MAX_VERSION_BITS_DEPLOYMENTS];
 
+    /** Enable or disable te miner fund by default */
+    bool enableMinerFund;
+
     /** Proof of work parameters */
     uint256 powLimit;
     bool fPowAllowMinDifficultyBlocks;
diff --git a/src/init.cpp b/src/init.cpp
--- a/src/init.cpp
+++ b/src/init.cpp
@@ -357,6 +357,7 @@
     std::vector<std::string> hidden_args = {
         "-h", "-help", "-dbcrashratio", "-forcecompactdb", "-parkdeepreorg",
         "-automaticunparking", "-replayprotectionactivationtime",
+        "-enableminerfund",
         // GUI args. These will be overwritten by SetupUIArgs for the GUI
         "-allowselfsignedrootcertificates", "-choosedatadir", "-lang=<lang>",
         "-min", "-resetguisettings", "-rootcertificates=<file>", "-splash",
diff --git a/src/miner.cpp b/src/miner.cpp
--- a/src/miner.cpp
+++ b/src/miner.cpp
@@ -15,6 +15,7 @@
 #include <consensus/merkle.h>
 #include <consensus/tx_verify.h>
 #include <consensus/validation.h>
+#include <minerfund.h>
 #include <net.h>
 #include <policy/policy.h>
 #include <policy/settings.h>
@@ -190,6 +191,16 @@
         nFees + GetBlockSubsidy(nHeight, consensusParams);
     coinbaseTx.vin[0].scriptSig = CScript() << nHeight << OP_0;
 
+    const std::vector<CTxDestination> whitelisted =
+        GetMinerFundWhitelist(consensusParams, pindexPrev);
+    if (!whitelisted.empty()) {
+        const Amount fund =
+            (MINER_FUND_RATIO * coinbaseTx.vout[0].nValue) / 100;
+        coinbaseTx.vout[0].nValue -= fund;
+        coinbaseTx.vout.emplace_back(fund,
+                                     GetScriptForDestination(whitelisted[0]));
+    }
+
     // Make sure the coinbase is big enough.
     uint64_t coinbaseSize = ::GetSerializeSize(coinbaseTx, PROTOCOL_VERSION);
     if (coinbaseSize < MIN_TX_SIZE) {
diff --git a/src/minerfund.h b/src/minerfund.h
new file mode 100644
--- /dev/null
+++ b/src/minerfund.h
@@ -0,0 +1,27 @@
+// Copyright (c) 2020 The Bitcoin developers
+// Distributed under the MIT software license, see the accompanying
+// file COPYING or http://www.opensource.org/licenses/mit-license.php.
+
+#ifndef BITCOIN_MINERFUND_H
+#define BITCOIN_MINERFUND_H
+
+#include <script/standard.h>
+
+#include <vector>
+
+class CBlockIndex;
+
+namespace Consensus {
+struct Params;
+}
+
+/**
+ * Percentage of the block reward to be sent to the fund.
+ */
+static constexpr int MINER_FUND_RATIO = 8;
+
+std::vector<CTxDestination>
+GetMinerFundWhitelist(const Consensus::Params &params,
+                      const CBlockIndex *pindexPrev);
+
+#endif // BITCOIN_MINERFUND_H
diff --git a/src/minerfund.cpp b/src/minerfund.cpp
new file mode 100644
--- /dev/null
+++ b/src/minerfund.cpp
@@ -0,0 +1,36 @@
+// Copyright (c) 2020 The Bitcoin developers
+// Distributed under the MIT software license, see the accompanying
+// file COPYING or http://www.opensource.org/licenses/mit-license.php.
+
+#include <minerfund.h>
+
+#include <chainparams.h>
+#include <consensus/activation.h>
+#include <key_io.h> // For DecodeDestination
+#include <util/system.h>
+#include <validation.h> // For VersionBitsBlockState
+
+static CTxDestination BuildDestination(const std::string &dest) {
+    const auto mainNetParams = CreateChainParams(CBaseChainParams::MAIN);
+    return DecodeDestination(dest, *mainNetParams);
+}
+
+static const CTxDestination &GetMinerFundDestination() {
+    static CTxDestination dest =
+        BuildDestination("pqnqv9lt7e5vjyp0w88zf2af0l92l8rxdgnlxww9j9");
+    return dest;
+}
+
+std::vector<CTxDestination>
+GetMinerFundWhitelist(const Consensus::Params &params,
+                      const CBlockIndex *pindexPrev) {
+    if (!gArgs.GetBoolArg("-enableminerfund", params.enableMinerFund)) {
+        return {};
+    }
+
+    if (!IsAxionEnabled(params, pindexPrev)) {
+        return {};
+    }
+
+    return {GetMinerFundDestination()};
+}
diff --git a/src/validation.cpp b/src/validation.cpp
--- a/src/validation.cpp
+++ b/src/validation.cpp
@@ -20,6 +20,7 @@
 #include <consensus/validation.h>
 #include <hash.h>
 #include <index/txindex.h>
+#include <minerfund.h>
 #include <policy/fees.h>
 #include <policy/mempool.h>
 #include <policy/policy.h>
@@ -1816,6 +1817,36 @@
                              REJECT_INVALID, "bad-cb-amount");
     }
 
+    const std::vector<CTxDestination> whitelist =
+        GetMinerFundWhitelist(consensusParams, pindex->pprev);
+    if (!whitelist.empty()) {
+        const Amount required = (MINER_FUND_RATIO * blockReward) / 100;
+
+        for (auto &o : block.vtx[0]->vout) {
+            if (o.nValue < required) {
+                // This output doesn't qualify because its amount is too low.
+                continue;
+            }
+
+            CTxDestination address;
+            if (!ExtractDestination(o.scriptPubKey, address)) {
+                // Cannot decode address.
+                continue;
+            }
+
+            if (std::find(whitelist.begin(), whitelist.end(), address) !=
+                whitelist.end()) {
+                goto MinerFundSuccess;
+            }
+        }
+
+        // We did not find an output that match the miner fund requirements.
+        return state.Invalid(BlockValidationResult::BLOCK_CONSENSUS,
+                             REJECT_INVALID, "bad-cb-minerfund");
+    }
+
+MinerFundSuccess:
+
     if (!control.Wait()) {
         return state.Invalid(BlockValidationResult::BLOCK_CONSENSUS,
                              REJECT_INVALID, "blk-bad-inputs",
diff --git a/test/functional/abc_feature_minerfund.py b/test/functional/abc_feature_minerfund.py
new file mode 100755
--- /dev/null
+++ b/test/functional/abc_feature_minerfund.py
@@ -0,0 +1,96 @@
+#!/usr/bin/env python3
+# Copyright (c) 2020 The Bitcoin developers
+# Distributed under the MIT software license, see the accompanying
+# file COPYING or http://www.opensource.org/licenses/mit-license.php.
+
+from test_framework.blocktools import (
+    create_block,
+    create_coinbase,
+)
+from test_framework.messages import ToHex
+from test_framework.test_framework import BitcoinTestFramework
+from test_framework.util import (
+    assert_equal,
+    assert_greater_than_or_equal,
+)
+
+from decimal import Decimal
+
+AXION_ACTIVATION_TIME = 2000000600
+
+MINER_FUND_RATIO = 8
+
+MINER_FUND_ADDR = 'bchreg:pqnqv9lt7e5vjyp0w88zf2af0l92l8rxdgd35g0pkl'
+
+
+class MinerFundTest(BitcoinTestFramework):
+    def set_test_params(self):
+        self.setup_clean_chain = True
+        self.num_nodes = 1
+        self.extra_args = [[
+            '-enableminerfund',
+            '-axionactivationtime={}'.format(AXION_ACTIVATION_TIME),
+        ]]
+
+    def run_test(self):
+        node = self.nodes[0]
+        address = node.get_deterministic_priv_key().address
+
+        self.log.info('Create some history')
+        for _ in range(0, 50):
+            node.generatetoaddress(1, address)
+
+        node = self.nodes[0]
+        address = node.get_deterministic_priv_key().address
+
+        # Move MTP forward to phonon activation
+        node.setmocktime(AXION_ACTIVATION_TIME)
+        node.generatetoaddress(6, address)
+        assert_equal(
+            node.getblockchaininfo()['mediantime'],
+            AXION_ACTIVATION_TIME)
+
+        # Let's remember the hash of this block for later use.
+        fork_block_hash = int(node.getbestblockhash(), 16)
+
+        def get_best_coinbase():
+            return node.getblock(node.getbestblockhash(), 2)['tx'][0]
+
+        # No money goes to the fund.
+        coinbase = get_best_coinbase()
+        assert_equal(len(coinbase['vout']), 1)
+        block_reward = coinbase['vout'][0]['value']
+
+        # First block with the new rules.
+        node.generatetoaddress(1, address)
+
+        # Now we send part of the coinbase to the fund.
+        coinbase = get_best_coinbase()
+        assert_equal(len(coinbase['vout']), 2)
+        assert_equal(
+            coinbase['vout'][1]['scriptPubKey']['addresses'][0],
+            MINER_FUND_ADDR)
+
+        total = Decimal()
+        for o in coinbase['vout']:
+            total += o['value']
+
+        assert_equal(total, block_reward)
+        assert_greater_than_or_equal(
+            coinbase['vout'][1]['value'],
+            (MINER_FUND_RATIO * total) / 100)
+
+        # Invalidate top block, submit a custom block that do not send anything
+        # to the fund and check it is rejected.
+        node.invalidateblock(node.getbestblockhash())
+
+        block_height = node.getblockcount() + 1
+        block = create_block(
+            fork_block_hash, create_coinbase(block_height), AXION_ACTIVATION_TIME + 1, version=4)
+        block.solve()
+
+        assert_equal(node.submitblock(ToHex(block)), 'bad-cb-minerfund')
+
+
+if __name__ == '__main__':
+    MinerFundTest().main()
diff --git a/test/lint/check-doc.py b/test/lint/check-doc.py
--- a/test/lint/check-doc.py
+++ b/test/lint/check-doc.py
@@ -42,6 +42,7 @@
 
 # list false positive undocumented arguments
 SET_FALSE_POSITIVE_UNDOCUMENTED = set(['-dbcrashratio',
+                                       '-enableminerfund',
                                        '-forcecompactdb',
                                        '-parkdeepreorg',
                                        '-automaticunparking',