diff --git a/divi/qa/rpc-tests/custom_address_update.py b/divi/qa/rpc-tests/custom_address_update.py
new file mode 100755
index 000000000..a37711305
--- /dev/null
+++ b/divi/qa/rpc-tests/custom_address_update.py
@@ -0,0 +1,141 @@
+#!/usr/bin/env python3
+# Copyright (c) 2020-2021 The DIVI developers
+# Distributed under the MIT/X11 software license, see the accompanying
+# file COPYING or http://www.opensource.org/licenses/mit-license.php.
+
+# Tests that nodes with support for custom reward addresses are compatible
+# to nodes without it before the change actually activates.  For this,
+# we run two masternodes (one with and one without support) and check
+# that they can both see each other's masternode.
+#
+# We use five nodes:
+# - node 0 is a masternode with default protocol (i.e. "new")
+# - node 1 is a masternode with previous protocol (i.e. "old")
+# - nodes 2-4 are just used to get above the "three full nodes" threshold
+
+from test_framework import BitcoinTestFramework
+from util import *
+from masternode import *
+
+import collections
+import copy
+import time
+
+OLD_PROTOCOL = 70915
+NEW_PROTOCOL = 71000
+
+
+class CustomAddressUpdateTest (MnTestFramework):
+
+  def __init__ (self):
+    super ().__init__ ()
+    self.base_args = ["-debug", "-nolistenonion", "-activeversion=%d" % OLD_PROTOCOL]
+    self.number_of_nodes = 5
+
+  def args_for (self, n):
+    res = copy.deepcopy (self.base_args)
+    if n == 1:
+      res.extend (["-protocolversion=%d" % OLD_PROTOCOL])
+    return res
+
+  def setup_network (self, config_line=None, extra_args=[]):
+    self.nodes = [
+      start_node (i, self.options.tmpdir, extra_args=self.args_for (i))
+      for i in range (self.number_of_nodes)
+    ]
+    self.setup = [None] * self.number_of_nodes
+
+    # We want to work with mock times that are beyond the genesis
+    # block timestamp but before current time (so that nodes being
+    # started up and before they get on mocktime aren't rejecting
+    # the on-disk blockchain).
+    self.time = 1580000000
+    assert self.time < time.time ()
+    set_node_times (self.nodes, self.time)
+
+    connect_nodes (self.nodes[0], 2)
+    connect_nodes (self.nodes[1], 2)
+    connect_nodes (self.nodes[2], 3)
+    connect_nodes (self.nodes[2], 4)
+    connect_nodes (self.nodes[3], 4)
+
+    self.is_network_split = False
+
+  def advance_time (self, dt=1):
+    """Advances mocktime by the given number of seconds."""
+
+    self.time += dt
+    set_node_times (self.nodes, self.time)
+
+  def mine_blocks (self, n):
+    """Mines blocks with node 2."""
+
+    self.nodes[2].setgenerate(True, n)
+    sync_blocks (self.nodes)
+
+  def run_test (self):
+    assert_equal (self.nodes[0].getnetworkinfo ()["protocolversion"], NEW_PROTOCOL)
+    assert_equal (self.nodes[1].getnetworkinfo ()["protocolversion"], OLD_PROTOCOL)
+
+    self.fund_masternodes ()
+    self.start_masternodes ()
+
+  def fund_masternodes (self):
+    print ("Funding masternodes...")
+
+    # The collateral needs 15 confirmations, and the masternode broadcast
+    # signature must be later than that block's timestamp.  Thus we start
+    # with a very early timestamp.
+    genesis = self.nodes[0].getblockhash (0)
+    genesisTime = self.nodes[0].getblockheader (genesis)["time"]
+    assert genesisTime < self.time
+    set_node_times (self.nodes, genesisTime)
+
+    self.nodes[0].setgenerate (True, 1)
+    sync_blocks (self.nodes)
+    self.nodes[1].setgenerate (True, 1)
+    sync_blocks (self.nodes)
+    self.mine_blocks (25)
+    assert_equal (self.nodes[0].getbalance (), 1250)
+    assert_equal (self.nodes[1].getbalance (), 1250)
+
+    self.setup_masternode (0, 0, "mn1", "copper")
+    self.setup_masternode (1, 1, "mn2", "copper")
+    self.mine_blocks (15)
+    set_node_times (self.nodes, self.time)
+    self.mine_blocks (1)
+
+  def start_masternodes (self):
+    print ("Starting masternodes...")
+
+    self.stop_masternode_daemons ()
+    self.start_masternode_daemons ()
+    self.connect_masternodes_to_peers ([2, 3, 4], updateMockTime=True)
+
+    # Start the masternodes after the nodes are back up and connected
+    # (so they will receive each other's broadcast).
+    assert_equal (self.broadcast_start ("mn1", True)["status"], "success")
+    assert_equal (self.broadcast_start ("mn2", True)["status"], "success")
+
+    # Check status of the masternodes themselves.
+    self.wait_for_masternodes_to_be_locally_active (updateMockTime=True)
+
+    # Both masternodes should see each other, independent of the
+    # protocol version used.
+    def sortByTxhash (entry):
+      return entry["txhash"]
+    lists = [
+      sorted (self.wait_for_mn_list_to_sync (self.nodes[i], 2), key=sortByTxhash)
+      for i in [0, 1]
+    ]
+    assert_equal (lists[0], lists[1])
+
+    lst = lists[0]
+    assert_equal (len (lst), 2)
+    for val in lst:
+      assert_equal (val["tier"], "COPPER")
+      assert_equal (val["status"], "ENABLED")
+
+
+if __name__ == '__main__':
+  CustomAddressUpdateTest ().main ()
diff --git a/divi/qa/rpc-tests/masternode.py b/divi/qa/rpc-tests/masternode.py
index 8242cd007..06135dac4 100644
--- a/divi/qa/rpc-tests/masternode.py
+++ b/divi/qa/rpc-tests/masternode.py
@@ -6,6 +6,7 @@
 
 from test_framework import BitcoinTestFramework
 from util import *
+import copy
 import time
 
 
@@ -45,7 +46,7 @@ def __init__(self, setup_data,address=None):
     if address is not None:
       self.address = address
 
-def setup_masternode(mempoolSync,controlNode, hostNode,alias,tier,hostIP, utxo = None):
+def setup_masternode(mempoolSync,controlNode, hostNode,alias,tier,hostIP, utxo = None, rewardAddr=""):
   """Calls fundmasternode with the given data and returns the
   MnConfigLine instance."""
   txdata = None
@@ -62,7 +63,7 @@ def setup_masternode(mempoolSync,controlNode, hostNode,alias,tier,hostIP, utxo =
   pubkey = controlNode.validateaddress(address)["pubkey"]
   if sync_required:
     mempoolSync()
-  data = hostNode.setupmasternode(alias,txdata["txhash"],str(txdata["vout"]), pubkey, hostIP)
+  data = hostNode.setupmasternode(alias,txdata["txhash"],str(txdata["vout"]), pubkey, hostIP, rewardAddr)
   return MnSetupData (data,address)
 
 class MnTestFramework(BitcoinTestFramework):
@@ -86,12 +87,12 @@ def for_each_masternode(self, masternode_function):
 
     return result
 
-  def setup_masternode(self,controlNodeIndex, hostNodeIndex,alias,tier,utxo=None):
+  def setup_masternode(self,controlNodeIndex, hostNodeIndex,alias,tier,utxo=None, rewardAddr=""):
     def mempoolSync():
       sync_mempools (self.nodes)
     controlNode = self.nodes[controlNodeIndex]
     hostNode = self.nodes[hostNodeIndex]
-    self.setup[hostNodeIndex] = setup_masternode(mempoolSync,controlNode,hostNode,alias, tier,"localhost:%d" % p2p_port (hostNodeIndex),utxo=utxo)
+    self.setup[hostNodeIndex] = setup_masternode(mempoolSync,controlNode,hostNode,alias, tier,"localhost:%d" % p2p_port (hostNodeIndex),utxo=utxo, rewardAddr=rewardAddr)
     self.mn_control_node_indices[alias] = controlNodeIndex
     self.mn_host_node_indices[alias] = hostNodeIndex
 
@@ -171,6 +172,11 @@ def wait_for_mnsync_on_nodes (self, updateMockTime = False):
         else:
           break
 
+  def args_for(self, n):
+    """Returns the arguments to use for node n.  Defaults to the base args
+    but can be overridden as needed."""
+    return copy.deepcopy(self.base_args)
+
   def stop_masternode_daemons(self):
     def stop_masternode(nodeIndex):
       if self.nodes[nodeIndex] is not None:
@@ -185,7 +191,7 @@ def start_masternode(nodeIndex):
       if self.nodes[nodeIndex] is not None:
         assert_equal("WARNING -- overwriting connection","")
       else:
-        args = self.base_args[:]
+        args = self.args_for(nodeIndex)
         conf = self.setup[nodeIndex].cfg
         args.append ("-masternode=%s" % conf.alias)
         self.nodes[nodeIndex] = start_node (nodeIndex, self.options.tmpdir, extra_args=args, mn_config_lines=[conf.line])
@@ -220,6 +226,7 @@ def find_mn(nodeIndex):
           assert_equal (local_status["status"], 4)
           assert_equal(local_status["txhash"],listedMN["txhash"])
           assert_equal(local_status["outputidx"],listedMN["outidx"])
+          assert_equal(local_status["rewardscript"],listedMN["rewardscript"])
           node_found = True
       assert_equal(node_found,True)
     self.for_each_masternode(find_mn)
@@ -237,4 +244,4 @@ def mock_wait(self,duration=1):
     for _ in range(duration):
       self.time +=1
       set_node_times(self.nodes,self.time)
-      time.sleep(0.01)
\ No newline at end of file
+      time.sleep(0.01)
diff --git a/divi/qa/rpc-tests/mnoperation.py b/divi/qa/rpc-tests/mnoperation.py
index e70732a65..e6dedcca1 100755
--- a/divi/qa/rpc-tests/mnoperation.py
+++ b/divi/qa/rpc-tests/mnoperation.py
@@ -57,6 +57,13 @@ def stop_node (self, n):
     stop_node (self.nodes[n], n)
     self.nodes[n] = None
 
+  def start_node (self, n):
+    """Starts a node."""
+
+    self.nodes[n] = start_node (n, self.options.tmpdir, extra_args=self.base_args)
+    for i in [3, 4, 5, 6]:
+      connect_nodes(self.nodes[n], i)
+
   def advance_time (self, dt=1,delay=None):
     """Advances mocktime by the given number of seconds."""
 
@@ -83,8 +90,9 @@ def fund_masternodes (self):
     self.mine_blocks (25)
     assert_equal (self.nodes[0].getbalance (), 6250)
 
+    self.rewardAddr = self.nodes[0].getnewaddress ("reward2")
     self.setup_masternode(0,1,"mn1","copper")
-    self.setup_masternode(0,2,"mn2","silver")
+    self.setup_masternode(0,2,"mn2","silver",rewardAddr=self.rewardAddr)
     self.mine_blocks (15)
     set_node_times (self.nodes, self.time)
     self.mine_blocks (1)
@@ -175,7 +183,7 @@ def payments_both_active (self):
     winners = self.verify_number_of_votes_exist_and_tally_winners(startHeight,endHeight, 2)
 
     addr1 = self.nodes[1].getmasternodestatus ()["addr"]
-    addr2 = self.nodes[2].getmasternodestatus ()["addr"]
+    addr2 = self.rewardAddr
     assert_equal (len (winners), 2)
     assert_greater_than (winners[addr1], 0)
     assert_greater_than (winners[addr2], 0)
@@ -215,11 +223,22 @@ def payments_one_active (self):
     addr = self.nodes[1].getmasternodestatus ()["addr"]
     self.verify_number_of_votes_exist_and_tally_winners(startHeight,endHeight,1,addr)
 
+  def check_rewards (self):
+    print ("Checking rewards in wallet...")
+
+    self.start_node (0)
+    sync_blocks (self.nodes)
+
+    assert_greater_than (self.nodes[0].getbalance ("alloc->mn1"), 100)
+    assert_equal (self.nodes[0].getbalance ("alloc->mn2"), 300)
+    assert_greater_than (self.nodes[0].getbalance ("reward2"), 0)
+
   def run_test (self):
     self.fund_masternodes ()
     self.start_masternodes ()
     self.payments_both_active ()
     self.payments_one_active ()
+    self.check_rewards ()
 
 if __name__ == '__main__':
   MnStatusTest ().main ()
diff --git a/divi/qa/rpc-tests/mnvaults.py b/divi/qa/rpc-tests/mnvaults.py
index 330736cd6..27e2ce4f7 100755
--- a/divi/qa/rpc-tests/mnvaults.py
+++ b/divi/qa/rpc-tests/mnvaults.py
@@ -1,5 +1,5 @@
 #!/usr/bin/env python3
-# Copyright (c) 2020 The DIVI developers
+# Copyright (c) 2020-2021 The DIVI developers
 # Distributed under the MIT/X11 software license, see the accompanying
 # file COPYING or http://www.opensource.org/licenses/mit-license.php.
 
@@ -28,7 +28,6 @@ class MnVaultsTest (MnTestFramework):
   def __init__ (self):
     super (MnVaultsTest, self).__init__ ()
     self.base_args = ["-debug=masternode", "-debug=mocktime"]
-    self.cfg = None
     self.number_of_nodes=7
 
   def connect_to_anchors(self,nodeID):
@@ -124,10 +123,10 @@ def fund_vault (self):
     assert_equal (signed["complete"], True)
     self.unvaultTx = signed["hex"]
 
-    self.setup_masternode(2,1,"mn","copper",{"txhash":txid,"vout":vout})
-    self.cfg = self.setup[1].cfg
-    # FIXME: Use reward address from node 0.
-    self.cfg.rewardAddr = addr
+    self.rewardAddr = self.nodes[0].getnewaddress ("reward")
+    self.setup_masternode(2, 1, "mn", "copper",
+                          utxo={"txhash":txid,"vout":vout},
+                          rewardAddr=self.rewardAddr)
     self.stop_masternode_daemons()
     self.start_masternode_daemons(updateMockTime=True)
     self.connect_masternodes_to_peers(range(3,7),updateMockTime=True)
@@ -204,16 +203,21 @@ def get_payments (self):
       self.advance_time (10)
       time.sleep(0.01)
 
+    # Mine some blocks normally to make sure the rewards are mature.
+    self.mine_blocks (20)
+
     # Check that some payments were made.
     winners = self.nodes[3].getmasternodewinners ()
     found = False
     for w in winners:
-      if w["winner"]["address"] == self.cfg.rewardAddr:
+      if w["winner"]["address"] == self.rewardAddr:
         found = True
         break
     assert_equal (found, True)
 
-    # FIXME: Check in wallet when we have a custom reward address.
+    # The payments should have been received at the reward address
+    # and in particular not be lost in the "destroyed" vault.
+    assert_greater_than (self.nodes[0].getbalance ("reward"), 0)
 
   def unvault (self):
     print ("Unvaulting the funds...")
diff --git a/divi/qa/rpc-tests/test_runner.py b/divi/qa/rpc-tests/test_runner.py
index 45aeec670..b478a2ce1 100755
--- a/divi/qa/rpc-tests/test_runner.py
+++ b/divi/qa/rpc-tests/test_runner.py
@@ -83,6 +83,7 @@
     'StakingVaultDeactivation.py',
     'StakingVaultSpam.py',
     'StakingVaultRedundancy.py',
+    'custom_address_update.py',
     'forknotify.py',
     'getchaintips.py',
     'httpbasics.py',
diff --git a/divi/src/ForkActivation.cpp b/divi/src/ForkActivation.cpp
index 66f868f75..8d4aedd64 100644
--- a/divi/src/ForkActivation.cpp
+++ b/divi/src/ForkActivation.cpp
@@ -28,7 +28,9 @@ const std::unordered_map<Fork, int64_t,std::hash<int>> ACTIVATION_TIMES = {
   {Fork::UniformLotteryWinners, unixTimestampForDec31stMidnight},
   /* FIXME: Schedule for a real time.  */
   {Fork::CheckLockTimeVerify, 2000000000},
-  {Fork::DeprecateMasternodes,2000000000}
+  {Fork::DeprecateMasternodes,2000000000},
+  /** FIXME: Set actual time once scheduled.  */
+  {Fork::CustomRewardAddresses, 2000000000},
 };
 
 const std::unordered_set<Fork, std::hash<int>> REQUIRE_BLOCK_INDEX_CONTEXT = {
diff --git a/divi/src/ForkActivation.h b/divi/src/ForkActivation.h
index d1617055c..28c87a709 100644
--- a/divi/src/ForkActivation.h
+++ b/divi/src/ForkActivation.h
@@ -24,6 +24,13 @@ enum Fork
   UniformLotteryWinners,
   CheckLockTimeVerify,
   DeprecateMasternodes,
+
+  /**
+   * Custom reward addresses for masternodes.  This is activated like other
+   * forks based on block time; but it only affects the network protocol
+   * we require from peers, not the actual consensus logic.
+   */
+  CustomRewardAddresses,
 };
 
 /**
diff --git a/divi/src/MasternodeBroadcastFactory.cpp b/divi/src/MasternodeBroadcastFactory.cpp
index f4cd33351..7fe7ba777 100644
--- a/divi/src/MasternodeBroadcastFactory.cpp
+++ b/divi/src/MasternodeBroadcastFactory.cpp
@@ -7,6 +7,7 @@
 #include <obfuscation.h>
 #include <chain.h>
 #include <base58address.h>
+#include <script/standard.h>
 #include <TransactionDiskAccessor.h>
 #include <timedata.h>
 #include <WalletTx.h>
@@ -64,6 +65,8 @@ bool createArgumentsFromConfig(
     bool collateralPrivKeyIsRemote,
     CTxIn& txin,
     std::pair<CKey,CPubKey>& masternodeKeyPair,
+    const CPubKey& pubkeyCollateralAddress,
+    CScript& rewardScript,
     MasternodeTier& nMasternodeTier)
 {
     const std::string strService = configEntry.getIp();
@@ -90,6 +93,12 @@ bool createArgumentsFromConfig(
     {
         return false;
     }
+
+    /* If a custom reward address should be used, this is overridden by
+       setupmasternode directly after creating the entry (not loaded through
+       the config file).  */
+    rewardScript = CMasternode::GetDefaultRewardScript(pubkeyCollateralAddress);
+
     return true;
 }
 
@@ -107,6 +116,7 @@ bool CMasternodeBroadcastFactory::CreateWithoutCollateralKey(
     const bool collateralPrivateKeyIsRemote = true;
     const bool deferRelay = true;
     CTxIn txin;
+    CScript rewardScript;
     std::pair<CKey,CPubKey> masternodeKeyPair;
     MasternodeTier nMasternodeTier;
 
@@ -120,6 +130,8 @@ bool CMasternodeBroadcastFactory::CreateWithoutCollateralKey(
         collateralPrivateKeyIsRemote,
         txin,
         masternodeKeyPair,
+        pubkeyCollateralAddress,
+        rewardScript,
         nMasternodeTier))
     {
         return false;
@@ -129,6 +141,7 @@ bool CMasternodeBroadcastFactory::CreateWithoutCollateralKey(
         txin,
         CService(configEntry.getIp()),
         pubkeyCollateralAddress,
+        rewardScript,
         pubkeyMasternode,
         nMasternodeTier,
         deferRelay,
@@ -174,13 +187,14 @@ bool CMasternodeBroadcastFactory::signBroadcast(
 
 CMasternodeBroadcast CMasternodeBroadcastFactory::constructBroadcast(
     const CService& newAddr, const CTxIn& newVin,
-    const CPubKey& pubKeyCollateralAddressNew, const CPubKey& pubKeyMasternodeNew,
+    const CPubKey& pubKeyCollateralAddressNew, const CScript& rewardScript, const CPubKey& pubKeyMasternodeNew,
     const MasternodeTier nMasternodeTier, const int protocolVersionIn)
 {
     CMasternode mn;
     mn.vin = newVin;
     mn.addr = newAddr;
     mn.pubKeyCollateralAddress = pubKeyCollateralAddressNew;
+    mn.rewardScript = rewardScript;
     mn.pubKeyMasternode = pubKeyMasternodeNew;
     mn.protocolVersion = protocolVersionIn;
     mn.nTier = nMasternodeTier;
@@ -191,6 +205,7 @@ void CMasternodeBroadcastFactory::createWithoutSignatures(
     const CTxIn& txin,
     const CService& service,
     const CPubKey& pubKeyCollateralAddressNew,
+    const CScript& rewardScript,
     const CPubKey& pubKeyMasternodeNew,
     const MasternodeTier nMasternodeTier,
     bool deferRelay,
@@ -200,7 +215,7 @@ void CMasternodeBroadcastFactory::createWithoutSignatures(
              CBitcoinAddress(pubKeyCollateralAddressNew.GetID()).ToString(),
              pubKeyMasternodeNew.GetID().ToString());
 
-    mnbRet = CMasternodeBroadcastFactory::constructBroadcast(service, txin, pubKeyCollateralAddressNew, pubKeyMasternodeNew, nMasternodeTier, PROTOCOL_VERSION);
+    mnbRet = CMasternodeBroadcastFactory::constructBroadcast(service, txin, pubKeyCollateralAddressNew, rewardScript, pubKeyMasternodeNew, nMasternodeTier, PROTOCOL_VERSION);
     const CMasternodePing mnp = (deferRelay
                                     ? createDelayedMasternodePing(mnbRet)
                                     : createCurrentPing(txin));
@@ -222,4 +237,4 @@ void CMasternodeBroadcastFactory::createWithoutSignatures(
         mnbRet.sigTime = pindexConf->GetBlockTime();
         LogPrint("masternode", "Using collateral confirmation time for broadcast: %d\n", mnbRet.sigTime);
     }
-}
\ No newline at end of file
+}
diff --git a/divi/src/MasternodeBroadcastFactory.h b/divi/src/MasternodeBroadcastFactory.h
index 36840fef6..e4e553c5e 100644
--- a/divi/src/MasternodeBroadcastFactory.h
+++ b/divi/src/MasternodeBroadcastFactory.h
@@ -40,6 +40,7 @@ class CMasternodeBroadcastFactory
         const CService& newAddr,
         const CTxIn& newVin,
         const CPubKey& pubKeyCollateralAddress,
+        const CScript& rewardScript,
         const CPubKey& pubKeyMasternode,
         MasternodeTier nMasternodeTier,
         int protocolVersionIn);
@@ -47,6 +48,7 @@ class CMasternodeBroadcastFactory
         const CTxIn& txin,
         const CService& service,
         const CPubKey& pubKeyCollateralAddressNew,
+        const CScript& rewardScript,
         const CPubKey& pubKeyMasternodeNew,
         MasternodeTier nMasternodeTier,
         bool deferRelay,
diff --git a/divi/src/RpcMasternodeFeatures.cpp b/divi/src/RpcMasternodeFeatures.cpp
index 9af24ad6d..bbbc4e741 100644
--- a/divi/src/RpcMasternodeFeatures.cpp
+++ b/divi/src/RpcMasternodeFeatures.cpp
@@ -45,6 +45,7 @@ ActiveMasternodeStatus::ActiveMasternodeStatus(
     , outputIndex()
     , netAddress()
     , collateralAddress()
+    , rewardScript()
     , statusCode()
     , statusMessage()
 {}
@@ -54,6 +55,7 @@ MasternodeListEntry::MasternodeListEntry(
     , outputIndex()
     , status()
     , collateralAddress()
+    , rewardScript()
     , protocolVersion()
     , signatureTime()
     , lastSeenTime()
@@ -228,6 +230,7 @@ ActiveMasternodeStatus GetActiveMasternodeStatus()
         result.outputIndex = std::to_string(activeMasternode.vin.prevout.n);
         result.netAddress = activeMasternode.service.ToString();
         result.collateralAddress = CBitcoinAddress(mn.pubKeyCollateralAddress.GetID()).ToString();
+        result.rewardScript = HexStr(mn.rewardScript);
         result.statusCode = std::to_string(activeMasternode.status);
         result.statusMessage = activeMasternode.GetStatus();
         result.activeMasternodeFound = true;
@@ -244,7 +247,6 @@ ActiveMasternodeStatus GetActiveMasternodeStatus()
 unsigned FindLastPayeePaymentTime(CBlockIndex* chainTip, const MasternodePaymentData& paymentData, const CMasternode& masternode, const unsigned maxBlockDepth)
 {
     assert(chainTip);
-    CScript mnPayee = GetScriptForDestination(masternode.pubKeyCollateralAddress.GetID());
     unsigned n = 0;
     for (unsigned int i = 1; chainTip && chainTip->nHeight > 0; i++) {
         if (n >= maxBlockDepth) {
@@ -262,7 +264,7 @@ unsigned FindLastPayeePaymentTime(CBlockIndex* chainTip, const MasternodePayment
                 Search for this payee, with at least 2 votes. This will aid in consensus allowing the network
                 to converge on the same payees quickly, then keep the same schedule.
             */
-            if (masternodePayees->HasPayeeWithVotes(mnPayee, 2)) {
+            if (masternodePayees->HasPayeeWithVotes(masternode.GetPaymentScript(), 2)) {
                 return chainTip->nTime + masternode.DeterministicTimeOffset();
             }
         }
@@ -314,7 +316,8 @@ std::vector<MasternodeListEntry> GetMasternodeList(std::string strFilter, CBlock
         entry.txHash = strTxHash;
         entry.outputIndex = oIdx;
         entry.status = strStatus;
-        entry.collateralAddress = CBitcoinAddress(masternode.pubKeyCollateralAddress.GetID()).ToString();
+        entry.collateralAddress = collateralAddress;
+        entry.rewardScript = HexStr(masternode.rewardScript);
         entry.protocolVersion = masternode.protocolVersion;
         entry.lastSeenTime = (int64_t)masternode.lastPing.sigTime;
         entry.activeTime = (int64_t)(masternode.lastPing.sigTime - masternode.sigTime);
diff --git a/divi/src/RpcMasternodeFeatures.h b/divi/src/RpcMasternodeFeatures.h
index cf2a610f4..87ab40395 100644
--- a/divi/src/RpcMasternodeFeatures.h
+++ b/divi/src/RpcMasternodeFeatures.h
@@ -20,6 +20,7 @@ struct ActiveMasternodeStatus
     std::string outputIndex;
     std::string netAddress;
     std::string collateralAddress;
+    std::string rewardScript;
     std::string statusCode;
     std::string statusMessage;
     ActiveMasternodeStatus();
@@ -31,6 +32,7 @@ struct MasternodeListEntry
     uint64_t outputIndex;
     std::string status;
     std::string collateralAddress;
+    std::string rewardScript;
     int protocolVersion;
     int64_t signatureTime;
     int64_t lastSeenTime;
diff --git a/divi/src/main.cpp b/divi/src/main.cpp
index e2b567b3c..300780028 100755
--- a/divi/src/main.cpp
+++ b/divi/src/main.cpp
@@ -22,6 +22,7 @@
 #include "coins.h"
 #include <defaultValues.h>
 #include "FeeRate.h"
+#include "ForkActivation.h"
 #include "init.h"
 #include "kernel.h"
 #include "masternode-payments.h"
diff --git a/divi/src/masternode-payments.cpp b/divi/src/masternode-payments.cpp
index ec0e71791..0fd9ce279 100644
--- a/divi/src/masternode-payments.cpp
+++ b/divi/src/masternode-payments.cpp
@@ -16,6 +16,7 @@
 #include "sync.h"
 #include "Logging.h"
 #include "utilmoneystr.h"
+#include "utilstrencodings.h"
 #include "netfulfilledman.h"
 #include <boost/filesystem.hpp>
 #include <boost/lexical_cast.hpp>
@@ -454,7 +455,7 @@ void ComputeMasternodesAndScores(
         // proper testing with a very small number of masternodes (which would
         // be scheduled and skipped all the time).
         if (Params().NetworkID() != CBaseChainParams::REGTEST) {
-            if (masternodePayments.IsScheduled(GetScriptForDestination(mn.pubKeyCollateralAddress.GetID()), nBlockHeight)) continue;
+            if (masternodePayments.IsScheduled(mn.GetPaymentScript(), nBlockHeight)) continue;
         }
 
         //it's too new, wait for a cycle
@@ -528,7 +529,7 @@ MnPaymentQueueData CMasternodePayments::GetMasternodePaymentQueue(const uint256&
     {
         if(pmn != nullptr && queueData.topTwentyMNPayees.size() < 2 * MNPAYMENTS_SIGNATURES_TOTAL)
         {
-            queueData.topTwentyMNPayees.push_back(GetScriptForDestination(pmn->pubKeyCollateralAddress.GetID()));
+            queueData.topTwentyMNPayees.push_back(pmn->GetPaymentScript());
         }
         else
         {
diff --git a/divi/src/masternode.cpp b/divi/src/masternode.cpp
index c4586ab94..eca4b33d5 100644
--- a/divi/src/masternode.cpp
+++ b/divi/src/masternode.cpp
@@ -6,7 +6,6 @@
 #include "masternode.h"
 
 #include <sync.h>
-#include <Logging.h>
 #include <boost/lexical_cast.hpp>
 #include <timedata.h>
 #include <script/standard.h>
@@ -14,6 +13,8 @@
 #include <streams.h>
 #include <net.h>
 
+#include <sstream>
+
 CAmount CMasternode::GetTierCollateralAmount(const MasternodeTier tier)
 {
     const auto& collateralMap = Params().MasternodeCollateralMap();
@@ -63,6 +64,7 @@ CMasternode::CMasternode(const CMasternode& other)
     vin = other.vin;
     addr = other.addr;
     pubKeyCollateralAddress = other.pubKeyCollateralAddress;
+    rewardScript = other.rewardScript;
     pubKeyMasternode = other.pubKeyMasternode;
     signature = other.signature;
     activeState = other.activeState;
@@ -83,6 +85,7 @@ CMasternode::CMasternode(const CMasternodeBroadcast& mnb)
     vin = mnb.vin;
     addr = mnb.addr;
     pubKeyCollateralAddress = mnb.pubKeyCollateralAddress;
+    rewardScript = mnb.rewardScript;
     pubKeyMasternode = mnb.pubKeyMasternode;
     signature = mnb.signature;
     activeState = MASTERNODE_ENABLED;
@@ -108,6 +111,7 @@ void CMasternode::swap(CMasternode& first, CMasternode& second) // nothrow
     swap(first.vin, second.vin);
     swap(first.addr, second.addr);
     swap(first.pubKeyCollateralAddress, second.pubKeyCollateralAddress);
+    swap(first.rewardScript, second.rewardScript);
     swap(first.pubKeyMasternode, second.pubKeyMasternode);
     swap(first.signature, second.signature);
     swap(first.activeState, second.activeState);
@@ -127,6 +131,16 @@ CMasternode& CMasternode::operator=(CMasternode from)
     return *this;
 }
 
+CScript CMasternode::GetDefaultRewardScript() const
+{
+    return GetDefaultRewardScript(pubKeyCollateralAddress);
+}
+
+CScript CMasternode::GetDefaultRewardScript(const CPubKey& pubKeyCollateralAddress)
+{
+    return GetScriptForDestination(pubKeyCollateralAddress.GetID());
+}
+
 bool CMasternode::IsEnabled() const
 {
     return activeState == MASTERNODE_ENABLED;
@@ -146,8 +160,7 @@ std::string CMasternode::Status() const
 
 CScript CMasternode::GetPaymentScript() const
 {
-    const CTxDestination dest(pubKeyCollateralAddress.GetID());
-    return GetScriptForDestination(dest);
+    return rewardScript;
 }
 
 static uint256 CalculateScoreHelper(CHashWriter hashWritter, int round)
@@ -246,10 +259,28 @@ void CMasternodeBroadcast::Relay() const
 
 std::string CMasternodeBroadcast::getMessageToSign() const
 {
-    std::string vchPubKey(pubKeyCollateralAddress.begin(), pubKeyCollateralAddress.end());
-    std::string vchPubKey2(pubKeyMasternode.begin(), pubKeyMasternode.end());
+    std::ostringstream message;
+
+    message << addr.ToString();
+    message << sigTime;
+    message << std::string(pubKeyCollateralAddress.begin(), pubKeyCollateralAddress.end());
+
+    /* The signature must commit also to the reward script.  We do this by
+       including it in the signed message if and only if it does not match
+       the collateral address.  This makes sure that the signature format
+       is backwards compatible for situations where we just have the
+       default reward script.  */
+    if (rewardScript != GetDefaultRewardScript()) {
+        /* Include a "marker", so that e.g. a zero-length script is different
+           from the default situation.  */
+        message << "rs";
+        message << std::string(rewardScript.begin(), rewardScript.end());
+    }
+
+    message << std::string(pubKeyMasternode.begin(), pubKeyMasternode.end());
+    message << protocolVersion;
 
-    return addr.ToString() + boost::lexical_cast<std::string>(sigTime) + vchPubKey + vchPubKey2 + boost::lexical_cast<std::string>(protocolVersion);
+    return message.str();
 }
 
 uint256 CMasternodeBroadcast::GetHash() const
diff --git a/divi/src/masternode.h b/divi/src/masternode.h
index 2cbd6525c..d4025a7dd 100644
--- a/divi/src/masternode.h
+++ b/divi/src/masternode.h
@@ -12,6 +12,7 @@
 #include <primitives/transaction.h>
 #include <masternode-tier.h>
 #include <MasternodePing.h>
+#include <Logging.h>
 
 #define MASTERNODE_MIN_CONFIRMATIONS 15
 #define MASTERNODE_MIN_MNP_SECONDS (10 * 60)
@@ -50,6 +51,10 @@ class CMasternode
     CTxIn vin;
     CService addr;
     CPubKey pubKeyCollateralAddress;
+    /** The script to which masternode rewards should be paid.  This often
+     *  is the collateral address, but (starting at some fork point) masternodes
+     *  can also choose a different script.  */
+    CScript rewardScript;
     CPubKey pubKeyMasternode;
     std::vector<unsigned char> signature;
     int activeState;
@@ -81,6 +86,11 @@ class CMasternode
         return !(a.vin == b.vin);
     }
 
+    /** Returns the "default" reward script, which is the one
+     *  matching the collateral address.  */
+    CScript GetDefaultRewardScript() const;
+    static CScript GetDefaultRewardScript(const CPubKey& pubKeyCollateralAddress);
+
     /** Calculates the score of the current masternode, based on the given
      *  scoring hash.  It should be the result of GetBlockHashForScoring of
      *  the target block height.  */
@@ -106,6 +116,7 @@ class CMasternode
         READWRITE(vin);
         READWRITE(addr);
         READWRITE(pubKeyCollateralAddress);
+        READWRITE(rewardScript);
         READWRITE(pubKeyMasternode);
         READWRITE(signature);
         READWRITE(sigTime);
@@ -149,6 +160,15 @@ class CMasternodeBroadcast : public CMasternode
         READWRITE(vin);
         READWRITE(addr);
         READWRITE(pubKeyCollateralAddress);
+        if (nVersion >= MN_REWARD_SCRIPT_VERSION) {
+            READWRITE(rewardScript);
+        } else {
+            if (ser_action.ForRead()) {
+                rewardScript = GetDefaultRewardScript();
+            } else if (rewardScript != GetDefaultRewardScript()) {
+                LogPrintf("WARNING: CMasternodeBroadcast - ignoring changed reward script for serialisation of %s\n", vin.prevout.ToString());
+            }
+        }
         READWRITE(pubKeyMasternode);
         READWRITE(signature);
         READWRITE(sigTime);
diff --git a/divi/src/masternodeman.cpp b/divi/src/masternodeman.cpp
index 475847718..688ad239c 100644
--- a/divi/src/masternodeman.cpp
+++ b/divi/src/masternodeman.cpp
@@ -183,6 +183,7 @@ bool CMasternodeMan::UpdateWithNewBroadcast(const CMasternodeBroadcast &mnb, CMa
     if (mnb.sigTime > masternode.sigTime) {
         masternode.pubKeyMasternode = mnb.pubKeyMasternode;
         masternode.pubKeyCollateralAddress = mnb.pubKeyCollateralAddress;
+        masternode.rewardScript = mnb.rewardScript;
         masternode.sigTime = mnb.sigTime;
         masternode.signature = mnb.signature;
         masternode.protocolVersion = mnb.protocolVersion;
@@ -230,6 +231,12 @@ bool CMasternodeMan::CheckInputsForMasternode(const CMasternodeBroadcast& mnb, i
 
 bool CMasternodeMan::CheckMasternodeBroadcastContext(CMasternodeBroadcast& mnb, int& nDoS)
 {
+    /* Until the protocol is updated, do not allow custom reward scripts.  */
+    if (ActiveProtocol() < MN_REWARD_SCRIPT_VERSION && mnb.rewardScript != mnb.GetDefaultRewardScript()) {
+        LogPrintf("%s : mnb - reward script does not match collateral address for %s\n", __func__, mnb.vin.prevout.ToString());
+        return false;
+    }
+
     // make sure signature isn't in the future (past is OK)
     if (mnb.sigTime > GetAdjustedTime() + 60 * 60) {
         LogPrintf("%s : mnb - Signature rejected, too far into the future %s\n", __func__, mnb.vin.prevout.hash);
diff --git a/divi/src/rpcmasternode.cpp b/divi/src/rpcmasternode.cpp
index 191956cf8..a87211ebe 100644
--- a/divi/src/rpcmasternode.cpp
+++ b/divi/src/rpcmasternode.cpp
@@ -264,9 +264,9 @@ Value signmnbroadcast(const Array& params, bool fHelp)
 
 Value setupmasternode(const Array& params, bool fHelp)
 {
-	if (fHelp || params.size() < 5 || params.size() > 6)
+	if (fHelp || params.size() < 5 || params.size() > 7)
 		throw std::runtime_error(
-			"setupmasternode alias txhash outputIndex collateralPubKey ip_address\n"
+			"setupmasternode alias txhash outputIndex collateralPubKey ip_address (reward_address)\n"
 			"\nStarts escrows funds for some purpose.\n"
 
 			"\nArguments:\n"
@@ -275,6 +275,7 @@ Value setupmasternode(const Array& params, bool fHelp)
             "3. outputIndex         (string, required) Output index transaction. \n"
             "4. collateralPubkey    (string, required) collateral pubkey. \n"
             "5. ip_address          (string, required) Local ip address of this node\n"
+            "6. reward_address      (string, optional) A custom reward address, defaults to the collateral address\n"
 			"\nResult:\n"
 			"\"protocol_version\"			(string) Protocol version used for serialization.\n"
             "\"message_to_sign\"			(string) Hex-encoded msg requiring collateral signature.\n"
@@ -317,6 +318,17 @@ Value setupmasternode(const Array& params, bool fHelp)
         throw JSONRPCError(RPC_INVALID_PARAMS,errorMsg);
     }
 
+    /* If we have a custom reward address, override the one from the broadcast.
+       This is fine, as it would only invalidate the broadcast signature and
+       the broadcast created is not yet signed anyway.  */
+    if (params.size() >= 6 && !params[5].get_str().empty())
+    {
+        const CBitcoinAddress addr(params[5].get_str());
+        if (!addr.IsValid())
+            throw JSONRPCError(RPC_INVALID_ADDRESS_OR_KEY, "Invalid reward address");
+        mnb.rewardScript = GetScriptForDestination(addr.Get());
+    }
+
     CDataStream ss(SER_NETWORK,PROTOCOL_VERSION);
     result.push_back(Pair("protocol_version", PROTOCOL_VERSION ));
     result.push_back(Pair("message_to_sign", HexStr(mnb.getMessageToSign()) ));
@@ -396,12 +408,13 @@ Value listmasternodes(const Array& params, bool fHelp)
     for(auto& masternodeEntry : masternodeList)
     {
         Object obj;
-        obj.reserve(10);
+        obj.reserve(11);
         obj.emplace_back("network", masternodeEntry.network);
         obj.emplace_back("txhash", masternodeEntry.txHash);
         obj.emplace_back("outidx", masternodeEntry.outputIndex);
         obj.emplace_back("status", masternodeEntry.status);
         obj.emplace_back("addr", masternodeEntry.collateralAddress);
+        obj.emplace_back("rewardscript", masternodeEntry.rewardScript);
         obj.emplace_back("version", masternodeEntry.protocolVersion);
         obj.emplace_back("lastseen", masternodeEntry.lastSeenTime);
         obj.emplace_back("activetime", masternodeEntry.activeTime);
@@ -564,6 +577,7 @@ Value getmasternodestatus (const Array& params, bool fHelp)
     mnObj.push_back(Pair("outputidx", (uint64_t)std::stoi(activeMNStatus.outputIndex) ));
     mnObj.push_back(Pair("netaddr", activeMNStatus.netAddress));
     mnObj.push_back(Pair("addr", activeMNStatus.collateralAddress));
+    mnObj.push_back(Pair("rewardscript", activeMNStatus.rewardScript));
     mnObj.push_back(Pair("status", std::stoi(activeMNStatus.statusCode) ));
     mnObj.push_back(Pair("message", activeMNStatus.statusMessage));
     return mnObj;
diff --git a/divi/src/test/ActiveMasternode_tests.cpp b/divi/src/test/ActiveMasternode_tests.cpp
index 18667802e..c2db7530f 100644
--- a/divi/src/test/ActiveMasternode_tests.cpp
+++ b/divi/src/test/ActiveMasternode_tests.cpp
@@ -131,4 +131,4 @@ BOOST_AUTO_TEST_CASE(willCannotResetStatusOfInactiveMasternodeWhenChainSyncIsReq
     BOOST_CHECK(activeMasternode_->status == ACTIVE_MASTERNODE_STARTED);
 }
 
-BOOST_AUTO_TEST_SUITE_END()
\ No newline at end of file
+BOOST_AUTO_TEST_SUITE_END()
diff --git a/divi/src/version-util.cpp b/divi/src/version-util.cpp
index f1fb453f9..13c4c8522 100644
--- a/divi/src/version-util.cpp
+++ b/divi/src/version-util.cpp
@@ -2,7 +2,7 @@
 
 #include <Logging.h>
 
-static int version = MIN_PEER_PROTO_VERSION_AFTER_ENFORCEMENT;
+static int version = MN_REWARD_SCRIPT_VERSION;
 const int& PROTOCOL_VERSION(version);
 
 void SetProtocolVersion(const int newVersion)
diff --git a/divi/src/version.cpp b/divi/src/version.cpp
index b4f3ebfd6..f80123ea8 100644
--- a/divi/src/version.cpp
+++ b/divi/src/version.cpp
@@ -1,17 +1,29 @@
 #include <version.h>
 
+#include <chain.h>
+#include <chainparams.h>
+#include <ForkActivation.h>
 #include <Settings.h>
 
+extern CChain chainActive;
 extern Settings& settings;
 
-// Note: whenever a protocol update is needed toggle between both implementations (comment out the formerly active one)
-//       so we can leave the existing clients untouched (old SPORK will stay on so they don't see even older clients).
-//       Those old clients won't react to the changes of the other (new) SPORK because at the time of their implementation
-//       it was the one which was commented out
 int ActiveProtocol()
 {
     if (settings.ParameterIsSet("-activeversion"))
         return settings.GetArg("-activeversion", 0);
 
+    /* On regtest, we set the new protocol as active without any further
+       ado.  This allows proper testing of the changed logic.  */
+    if (Params().NetworkID() == CBaseChainParams::REGTEST)
+        return MN_REWARD_SCRIPT_VERSION;
+
+    /* Otherwise, the protocol update is tied to time-based activation of
+       a network fork (which in fact does not fork consensus but just the
+       network protocol).  */
+    const CBlockIndex* tip = chainActive.Tip();
+    if (tip != nullptr && ActivationState(tip).IsActive(Fork::CustomRewardAddresses))
+        return MN_REWARD_SCRIPT_VERSION;
+
     return MIN_PEER_PROTO_VERSION_AFTER_ENFORCEMENT;
 }
diff --git a/divi/src/version.h b/divi/src/version.h
index f85f41a05..9079f8253 100644
--- a/divi/src/version.h
+++ b/divi/src/version.h
@@ -33,6 +33,9 @@ static constexpr int MEMPOOL_GD_VERSION = 60002;
 //! "filter*" commands are disabled without NODE_BLOOM after and including this version
 static constexpr int NO_BLOOM_VERSION = 70005;
 
+//! include explicit reward script in masternode broadcasts
+static constexpr int MN_REWARD_SCRIPT_VERSION = 71000;
+
 /** The current protocol version.   Since it can be changed through -protocolversion
  *  for testing, it is not a constexpr but a real variable.  */
 extern const int& PROTOCOL_VERSION;