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..43679e2e1
--- /dev/null
+++ b/divi/qa/rpc-tests/custom_address_update.py
@@ -0,0 +1,179 @@
+#!/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 time
+
+OLD_PROTOCOL = 70915
+NEW_PROTOCOL = 71000
+
+
+def args_for (n):
+  base = ["-debug", "-nolistenonion", "-activeversion=%d" % OLD_PROTOCOL]
+  if n == 1:
+    base.extend (["-protocolversion=%d" % OLD_PROTOCOL])
+  return base
+
+
+class CustomAddressUpdateTest (BitcoinTestFramework):
+
+  def setup_chain (self):
+    for i in range (5):
+      initialize_datadir (self.options.tmpdir, i)
+
+  def setup_network (self, config_line=None, extra_args=[]):
+    self.nodes = [
+      start_node (i, self.options.tmpdir, extra_args=args_for (i))
+      for i in range (5)
+    ]
+
+    # 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 start_node (self, n):
+    """Starts node n (0 or 1) with the proper arguments
+    and masternode config for it."""
+
+    assert n in [0, 1]
+    configs = [[c.getLine ()] for c in self.cfg]
+
+    args = args_for (n)
+    args.append ("-masternode")
+    args.append ("-masternodeprivkey=%s" % self.cfg[n].privkey)
+    args.append ("-masternodeaddr=127.0.0.1:%d" % p2p_port (n))
+
+    self.nodes[n] = start_node (n, self.options.tmpdir,
+                                extra_args=args, mn_config_lines=configs[n])
+    self.nodes[n].setmocktime (self.time)
+
+    for i in [2, 3, 4]:
+      connect_nodes (self.nodes[n], i)
+    sync_blocks (self.nodes)
+
+  def stop_node (self, n):
+    """Stops node n."""
+
+    stop_node (self.nodes[n], n)
+    self.nodes[n] = None
+
+  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)
+
+    id1 = self.nodes[0].allocatefunds ("masternode", "mn1", "copper")["txhash"]
+    id2 = self.nodes[1].allocatefunds ("masternode", "mn2", "copper")["txhash"]
+    sync_mempools (self.nodes)
+    self.mine_blocks (15)
+    set_node_times (self.nodes, self.time)
+    self.mine_blocks (1)
+
+    self.cfg = [
+      fund_masternode (self.nodes[0], "mn1", "copper", id1, "localhost:%d" % p2p_port (0)),
+      fund_masternode (self.nodes[1], "mn2", "copper", id2, "localhost:%d" % p2p_port (1)),
+    ]
+
+  def start_masternodes (self):
+    print ("Starting masternodes...")
+
+    for i in range (2):
+      self.stop_node (i)
+      self.start_node (i)
+
+    # Start the masternodes after the nodes are back up and connected
+    # (so they will receive each other's broadcast).
+    for i in range (2):
+      res = self.nodes[i].startmasternode ("mn%d" % (i + 1))
+      assert_equal (res, {"status": "success"})
+
+    # Check status of the masternodes themselves.
+    for i in [0, 1]:
+      data = self.nodes[i].getmasternodestatus ()
+      assert_equal (data["status"], 4)
+      assert_equal (data["txhash"], self.cfg[i].txid)
+      assert_equal (data["outputidx"], self.cfg[i].vout)
+      assert_equal (data["message"], "Masternode successfully started")
+
+    # Both masternodes should see each other, independent of the
+    # protocol version used.
+    lists = [{}] * 2
+    for i in range (2):
+      cur = self.nodes[i].listmasternodes ()
+      while len (cur) < 2:
+        time.sleep (0.1)
+        cur = self.nodes[i].listmasternodes ()
+      for c in cur:
+        lists[i][c["txhash"]] = c
+    assert_equal (lists[0], lists[1])
+
+    lst = lists[0]
+    assert_equal (len (lst), 2)
+    for val in lst.values ():
+      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 6fc101943..254446043 100644
--- a/divi/qa/rpc-tests/masternode.py
+++ b/divi/qa/rpc-tests/masternode.py
@@ -12,7 +12,7 @@ class MnConfigLine (object):
 
   def __init__ (self, line):
     parts = line.split (" ")
-    assert_equal (len (parts), 5)
+    assert len (parts) in [5, 6]
 
     self.line = line
 
@@ -22,6 +22,21 @@ def __init__ (self, line):
     self.txid = parts[3]
     self.vout = int (parts[4])
 
+    if len (parts) >= 6:
+      self.rewardAddr = parts[5]
+    else:
+      self.rewardAddr = None
+
+  def getLine (self):
+    """Returns the config line as string, to put into masternode.conf."""
+
+    res = "%s %s %s %s %d" % (self.alias, self.ip, self.privkey,
+                              self.txid, self.vout)
+    if self.rewardAddr is not None:
+      res += " %s" % self.rewardAddr
+
+    return res
+
 
 def fund_masternode (node, alias, tier, txid, ip):
   """Calls fundmasternode with the given data and returns the
diff --git a/divi/qa/rpc-tests/mncollateral.py b/divi/qa/rpc-tests/mncollateral.py
index 1614c74c5..ce6bb4305 100755
--- a/divi/qa/rpc-tests/mncollateral.py
+++ b/divi/qa/rpc-tests/mncollateral.py
@@ -59,6 +59,7 @@ def run_test (self):
     assert_equal (cfg.alias, "spent")
     assert_equal (cfg.ip, "1.2.3.4:51476")
     assert_equal (cfg.txid, txid)
+    assert_equal (cfg.rewardAddr, None)
     assert_equal (node.gettxout (cfg.txid, cfg.vout)["value"], 300)
 
     # It should still be possible to spend the coins, invalidating the
diff --git a/divi/qa/rpc-tests/mnoperation.py b/divi/qa/rpc-tests/mnoperation.py
index 57ccf0b47..af88f3e0a 100755
--- a/divi/qa/rpc-tests/mnoperation.py
+++ b/divi/qa/rpc-tests/mnoperation.py
@@ -69,9 +69,9 @@ def start_node (self, n):
     and masternode config for it."""
 
     configs = [
-      [c.line for c in self.cfg],
-      [self.cfg[0].line],
-      [self.cfg[1].line],
+      [c.getLine () for c in self.cfg],
+      [self.cfg[0].getLine ()],
+      [self.cfg[1].getLine ()],
     ]
 
     args = self.base_args[:]
@@ -141,6 +141,8 @@ def fund_masternodes (self):
       fund_masternode (self.nodes[0], "mn2", "silver", id2, "localhost:%d" % p2p_port (2)),
     ]
 
+    self.cfg[1].rewardAddr = self.nodes[0].getnewaddress ("reward2")
+
   def start_masternodes (self):
     print ("Starting masternodes...")
 
@@ -187,8 +189,9 @@ def start_masternodes (self):
     assert_equal (lst[1]["tier"], "SILVER")
     for i in range (2):
       assert_equal (lst[i]["status"], "ENABLED")
-      assert_equal (lst[i]["addr"],
-                    self.nodes[i + 1].getmasternodestatus ()["addr"])
+      n = self.nodes[i + 1]
+      for key in ["addr", "rewardscript"]:
+        assert_equal (lst[i][key], n.getmasternodestatus ()[key])
       assert_equal (lst[i]["txhash"], self.cfg[i].txid)
       assert_equal (lst[i]["outidx"], self.cfg[i].vout)
 
@@ -263,7 +266,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.cfg[1].rewardAddr
     assert_equal (len (winners), 2)
     assert_greater_than (winners[addr1], 0)
     assert_greater_than (winners[addr2], 0)
@@ -308,8 +311,9 @@ def check_rewards (self):
     self.start_node (0)
     sync_blocks (self.nodes)
 
-    assert_greater_than (self.nodes[0].getbalance ("alloc->mn1"), 0)
-    assert_greater_than (self.nodes[0].getbalance ("alloc->mn2"), 0)
+    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)
 
 
 if __name__ == '__main__':
diff --git a/divi/qa/rpc-tests/test_runner.py b/divi/qa/rpc-tests/test_runner.py
index ab807ee38..05c581744 100755
--- a/divi/qa/rpc-tests/test_runner.py
+++ b/divi/qa/rpc-tests/test_runner.py
@@ -78,6 +78,7 @@
     'StakingVaultStaking.py',
     'StakingVaultDeactivation.py',
     'StakingVaultSpam.py',
+    'custom_address_update.py',
     'forknotify.py',
     'getchaintips.py',
     'httpbasics.py',
diff --git a/divi/src/ForkActivation.cpp b/divi/src/ForkActivation.cpp
index a05e2dd35..384108346 100644
--- a/divi/src/ForkActivation.cpp
+++ b/divi/src/ForkActivation.cpp
@@ -25,6 +25,9 @@ const std::unordered_map<Fork, int64_t,std::hash<int>> ACTIVATION_TIMES = {
   {Fork::TestByTimestamp, 1000000000},
   {Fork::HardenedStakeModifier, unixTimestampForDec31stMidnight},
   {Fork::UniformLotteryWinners, unixTimestampForDec31stMidnight},
+
+  /** FIXME: Set actual time once scheduled.  */
+  {Fork::CustomRewardAddresses, 2000000000},
 };
 
 } // anonymous namespace
diff --git a/divi/src/ForkActivation.h b/divi/src/ForkActivation.h
index 79aeb7ba6..e1c43dc6d 100644
--- a/divi/src/ForkActivation.h
+++ b/divi/src/ForkActivation.h
@@ -22,6 +22,13 @@ enum Fork
   TestByTimestamp,
   HardenedStakeModifier,
   UniformLotteryWinners,
+
+  /**
+   * 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 fac4d3730..4bc84412b 100644
--- a/divi/src/MasternodeBroadcastFactory.cpp
+++ b/divi/src/MasternodeBroadcastFactory.cpp
@@ -8,6 +8,7 @@
 #include <wallet.h>
 #include <chain.h>
 #include <base58address.h>
+#include <script/standard.h>
 #include <TransactionDiskAccessor.h>
 #include <timedata.h>
 #include <WalletTx.h>
@@ -17,7 +18,10 @@ extern CChain chainActive;
 extern bool fReindex;
 extern bool fImporting;
 
-bool CMasternodeBroadcastFactory::checkBlockchainSync(std::string& strErrorRet, bool fOffline)
+namespace
+{
+
+bool checkBlockchainSync(std::string& strErrorRet, bool fOffline)
 {
      if (!fOffline && !IsBlockchainSynced()) {
         strErrorRet = "Sync in progress. Must wait until sync is complete to start Masternode";
@@ -26,7 +30,7 @@ bool CMasternodeBroadcastFactory::checkBlockchainSync(std::string& strErrorRet,
     }
     return true;
 }
-bool CMasternodeBroadcastFactory::setMasternodeKeys(
+bool setMasternodeKeys(
     const std::string& strKeyMasternode,
     std::pair<CKey,CPubKey>& masternodeKeyPair,
     std::string& strErrorRet)
@@ -38,7 +42,7 @@ bool CMasternodeBroadcastFactory::setMasternodeKeys(
     }
     return true;
 }
-bool CMasternodeBroadcastFactory::setMasternodeCollateralKeys(
+bool setMasternodeCollateralKeys(
     const std::string& txHash,
     const std::string& outputIndex,
     const std::string& service,
@@ -63,7 +67,7 @@ bool CMasternodeBroadcastFactory::setMasternodeCollateralKeys(
     return true;
 }
 
-bool CMasternodeBroadcastFactory::checkMasternodeCollateral(
+bool checkMasternodeCollateral(
     const CTxIn& txin,
     const std::string& txHash,
     const std::string& outputIndex,
@@ -95,13 +99,14 @@ bool CMasternodeBroadcastFactory::checkMasternodeCollateral(
     return true;
 }
 
-bool CMasternodeBroadcastFactory::createArgumentsFromConfig(
+bool createArgumentsFromConfig(
     const CMasternodeConfig::CMasternodeEntry configEntry,
     std::string& strErrorRet,
     bool fOffline,
     bool collateralPrivKeyIsRemote,
     CTxIn& txin,
     std::pair<CKey,CPubKey>& masternodeKeyPair,
+    CScript& rewardScript,
     std::pair<CKey,CPubKey>& masternodeCollateralKeyPair,
     MasternodeTier& nMasternodeTier
     )
@@ -118,9 +123,23 @@ bool CMasternodeBroadcastFactory::createArgumentsFromConfig(
     {
         return false;
     }
+
+    if (configEntry.getRewardAddress().empty())
+        rewardScript = CMasternode::GetDefaultRewardScript(masternodeCollateralKeyPair.second);
+    else {
+        const CBitcoinAddress addr(configEntry.getRewardAddress());
+        if (!addr.IsValid()) {
+            strErrorRet = strprintf("Invalid reward address for masternode: %s", configEntry.getRewardAddress());
+            return false;
+        }
+        rewardScript = GetScriptForDestination(addr.Get());
+    }
+
     return true;
 }
 
+} // anonymous namespace
+
 bool CMasternodeBroadcastFactory::Create(
     const CMasternodeConfig::CMasternodeEntry configEntry,
     CPubKey pubkeyCollateralAddress,
@@ -132,6 +151,7 @@ bool CMasternodeBroadcastFactory::Create(
     const bool deferRelay = true;
     CTxIn txin;
     std::pair<CKey,CPubKey> masternodeCollateralKeyPair;
+    CScript rewardScript;
     std::pair<CKey,CPubKey> masternodeKeyPair;
     MasternodeTier nMasternodeTier;
 
@@ -142,6 +162,7 @@ bool CMasternodeBroadcastFactory::Create(
         collateralPrivateKeyIsRemote,
         txin,
         masternodeKeyPair,
+        rewardScript,
         masternodeCollateralKeyPair,
         nMasternodeTier))
     {
@@ -152,6 +173,7 @@ bool CMasternodeBroadcastFactory::Create(
         txin,
         CService(configEntry.getIp()),
         pubkeyCollateralAddress,
+        rewardScript,
         masternodeKeyPair.second,
         nMasternodeTier,
         deferRelay,
@@ -180,6 +202,7 @@ bool CMasternodeBroadcastFactory::Create(
 
     CTxIn txin;
     std::pair<CKey,CPubKey> masternodeCollateralKeyPair;
+    CScript rewardScript;
     std::pair<CKey,CPubKey> masternodeKeyPair;
     MasternodeTier nMasternodeTier;
 
@@ -190,6 +213,7 @@ bool CMasternodeBroadcastFactory::Create(
         collateralPrivateKeyIsRemote,
         txin,
         masternodeKeyPair,
+        rewardScript,
         masternodeCollateralKeyPair,
         nMasternodeTier))
     {
@@ -200,6 +224,7 @@ bool CMasternodeBroadcastFactory::Create(
                 CService(strService),
                 masternodeCollateralKeyPair.first,
                 masternodeCollateralKeyPair.second,
+                rewardScript,
                 masternodeKeyPair.first,
                 masternodeKeyPair.second,
                 nMasternodeTier,
@@ -278,10 +303,11 @@ CMasternodePing createDelayedMasternodePing(const CMasternodeBroadcast& mnb)
 } // anonymous namespace
 
 void CMasternodeBroadcastFactory::createWithoutSignatures(
-    CTxIn txin,
-    CService service,
-    CPubKey pubKeyCollateralAddressNew,
-    CPubKey pubKeyMasternodeNew,
+    const CTxIn& txin,
+    const CService& service,
+    const CPubKey& pubKeyCollateralAddressNew,
+    const CScript& rewardScript,
+    const CPubKey& pubKeyMasternodeNew,
     const MasternodeTier nMasternodeTier,
     bool deferRelay,
     CMasternodeBroadcast& mnbRet)
@@ -290,7 +316,9 @@ void CMasternodeBroadcastFactory::createWithoutSignatures(
              CBitcoinAddress(pubKeyCollateralAddressNew.GetID()).ToString(),
              pubKeyMasternodeNew.GetID().ToString());
 
-    mnbRet = CMasternodeBroadcast(service, txin, pubKeyCollateralAddressNew, pubKeyMasternodeNew, nMasternodeTier, PROTOCOL_VERSION);
+    mnbRet = CMasternodeBroadcast(service, txin,
+                                  pubKeyCollateralAddressNew, rewardScript, pubKeyMasternodeNew,
+                                  nMasternodeTier, PROTOCOL_VERSION);
     const CMasternodePing mnp = (deferRelay
                                     ? createDelayedMasternodePing(mnbRet)
                                     : createCurrentPing(txin));
@@ -299,12 +327,13 @@ void CMasternodeBroadcastFactory::createWithoutSignatures(
 }
 
 bool CMasternodeBroadcastFactory::Create(
-    CTxIn txin,
-    CService service,
-    CKey keyCollateralAddressNew,
-    CPubKey pubKeyCollateralAddressNew,
-    CKey keyMasternodeNew,
-    CPubKey pubKeyMasternodeNew,
+    const CTxIn& txin,
+    const CService& service,
+    const CKey& keyCollateralAddressNew,
+    const CPubKey& pubKeyCollateralAddressNew,
+    const CScript& rewardScript,
+    const CKey& keyMasternodeNew,
+    const CPubKey& pubKeyMasternodeNew,
     const MasternodeTier nMasternodeTier,
     std::string& strErrorRet,
     CMasternodeBroadcast& mnbRet,
@@ -314,7 +343,7 @@ bool CMasternodeBroadcastFactory::Create(
     if (fImporting || fReindex) return false;
 
     createWithoutSignatures(
-        txin,service,pubKeyCollateralAddressNew,pubKeyMasternodeNew,nMasternodeTier,deferRelay,mnbRet);
+        txin,service,pubKeyCollateralAddressNew,rewardScript,pubKeyMasternodeNew,nMasternodeTier,deferRelay,mnbRet);
 
     if(!provideSignatures(keyMasternodeNew,pubKeyMasternodeNew,keyCollateralAddressNew,mnbRet,strErrorRet))
     {
diff --git a/divi/src/MasternodeBroadcastFactory.h b/divi/src/MasternodeBroadcastFactory.h
index e7edd478a..b44c1c7f6 100644
--- a/divi/src/MasternodeBroadcastFactory.h
+++ b/divi/src/MasternodeBroadcastFactory.h
@@ -37,10 +37,11 @@ class CMasternodeBroadcastFactory
         std::string& strErrorRet);
 private:
     static void createWithoutSignatures(
-        CTxIn txin,
-        CService service,
-        CPubKey pubKeyCollateralAddressNew,
-        CPubKey pubKeyMasternodeNew,
+        const CTxIn& txin,
+        const CService& service,
+        const CPubKey& pubKeyCollateralAddressNew,
+        const CScript& rewardScript,
+        const CPubKey& pubKeyMasternodeNew,
         MasternodeTier nMasternodeTier,
         bool deferRelay,
         CMasternodeBroadcast& mnbRet);
@@ -57,45 +58,16 @@ class CMasternodeBroadcastFactory
         CMasternodeBroadcast& mnb,
         std::string& strErrorRet);
 
-    static bool Create(CTxIn vin,
-                        CService service,
-                        CKey keyCollateralAddressNew,
-                        CPubKey pubKeyCollateralAddressNew,
-                        CKey keyMasternodeNew,
-                        CPubKey pubKeyMasternodeNew,
-                        MasternodeTier nMasternodeTier,
-                        std::string& strErrorRet,
-                        CMasternodeBroadcast& mnbRet,
-                        bool deferRelay);
-    static bool checkBlockchainSync(
-        std::string& strErrorRet, bool fOffline);
-    static bool setMasternodeKeys(
-        const std::string& strKeyMasternode,
-        std::pair<CKey,CPubKey>& masternodeKeyPair,
-        std::string& strErrorRet);
-    static bool setMasternodeCollateralKeys(
-        const std::string& txHash,
-        const std::string& outputIndex,
-        const std::string& service,
-        bool collateralPrivKeyIsRemote,
-        CTxIn& txin,
-        std::pair<CKey,CPubKey>& masternodeCollateralKeyPair,
-        std::string& error);
-    static bool checkMasternodeCollateral(
-        const CTxIn& txin,
-        const std::string& txHash,
-        const std::string& outputIndex,
-        const std::string& service,
-        MasternodeTier& nMasternodeTier,
-        std::string& strErrorRet);
-    static bool createArgumentsFromConfig(
-        const CMasternodeConfig::CMasternodeEntry configEntry,
-        std::string& strErrorRet,
-        bool fOffline,
-        bool collateralPrivKeyIsRemote,
-        CTxIn& txin,
-        std::pair<CKey,CPubKey>& masternodeKeyPair,
-        std::pair<CKey,CPubKey>& masternodeCollateralKeyPair,
-        MasternodeTier& nMasternodeTier);
+    static bool Create(const CTxIn& vin,
+                       const CService& service,
+                       const CKey& keyCollateralAddressNew,
+                       const CPubKey& pubKeyCollateralAddressNew,
+                       const CScript& rewardScript,
+                       const CKey& keyMasternodeNew,
+                       const CPubKey& pubKeyMasternodeNew,
+                       MasternodeTier nMasternodeTier,
+                       std::string& strErrorRet,
+                       CMasternodeBroadcast& mnbRet,
+                       bool deferRelay);
 };
-#endif //MASTERNODE_BROADCAST_FACTORY_H
\ No newline at end of file
+#endif //MASTERNODE_BROADCAST_FACTORY_H
diff --git a/divi/src/MasternodeModule.cpp b/divi/src/MasternodeModule.cpp
index 118e979ec..1e29011a4 100644
--- a/divi/src/MasternodeModule.cpp
+++ b/divi/src/MasternodeModule.cpp
@@ -241,6 +241,7 @@ std::vector<MasternodeListEntry> GetMasternodeList(std::string strFilter)
         entry.outputIndex = oIdx;
         entry.status = strStatus;
         entry.collateralAddress = CBitcoinAddress(masternode.pubKeyCollateralAddress.GetID()).ToString();
+        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);
@@ -262,6 +263,7 @@ ActiveMasternodeStatus GetActiveMasternodeStatus()
         result.outputIndex = std::to_string(activeMasternode.vin.prevout.n);
         result.netAddress = activeMasternode.service.ToString();
         result.collateralAddress = CBitcoinAddress(pmn->pubKeyCollateralAddress.GetID()).ToString();
+        result.rewardScript = HexStr(pmn->rewardScript);
         result.statusCode = std::to_string(activeMasternode.status);
         result.statusMessage = activeMasternode.GetStatus();
         result.activeMasternodeFound = true;
diff --git a/divi/src/MasternodeModule.h b/divi/src/MasternodeModule.h
index 787871d21..98f7819e3 100644
--- a/divi/src/MasternodeModule.h
+++ b/divi/src/MasternodeModule.h
@@ -46,6 +46,7 @@ struct ActiveMasternodeStatus
     std::string outputIndex;
     std::string netAddress;
     std::string collateralAddress;
+    std::string rewardScript;
     std::string statusCode;
     std::string statusMessage;
     ActiveMasternodeStatus(
@@ -54,6 +55,7 @@ struct ActiveMasternodeStatus
         , outputIndex()
         , netAddress()
         , collateralAddress()
+        , rewardScript()
         , statusCode()
         , statusMessage()
     {}
@@ -66,6 +68,7 @@ struct MasternodeListEntry
     uint64_t outputIndex;
     std::string status;
     std::string collateralAddress;
+    std::string rewardScript;
     int protocolVersion;
     int64_t signatureTime;
     int64_t lastSeenTime;
@@ -78,6 +81,7 @@ struct MasternodeListEntry
         , outputIndex()
         , status()
         , collateralAddress()
+        , rewardScript()
         , protocolVersion()
         , signatureTime()
         , lastSeenTime()
@@ -104,4 +108,4 @@ bool LoadMasternodeDataFromDisk(UIMessenger& uiMessenger,std::string pathToDataD
 void DumpMasternodeDataToDisk();
 CMasternodePayments& GetMasternodePayments();
 bool InitializeMasternodeIfRequested(const Settings& settings, bool transactionIndexEnabled, std::string& errorMessage);
-#endif //MASTERNODE_MODULE_H
\ No newline at end of file
+#endif //MASTERNODE_MODULE_H
diff --git a/divi/src/main.cpp b/divi/src/main.cpp
index a66520311..cef693d78 100755
--- a/divi/src/main.cpp
+++ b/divi/src/main.cpp
@@ -15,6 +15,7 @@
 #include "BlockSigning.h"
 #include "checkpoints.h"
 #include "checkqueue.h"
+#include "ForkActivation.h"
 #include "init.h"
 #include "kernel.h"
 #include "masternode-payments.h"
@@ -1202,7 +1203,10 @@ void Misbehaving(NodeId pnode, int howmuch)
         LogPrintf("Misbehaving: %s (%d -> %d)\n", state->name, state->nMisbehavior - howmuch, state->nMisbehavior);
 }
 
-void static InvalidChainFound(CBlockIndex* pindexNew)
+namespace
+{
+
+void InvalidChainFound(CBlockIndex* pindexNew)
 {
     if (!pindexBestInvalid || pindexNew->nChainWork > pindexBestInvalid->nChainWork)
         pindexBestInvalid = pindexNew;
@@ -1217,7 +1221,7 @@ void static InvalidChainFound(CBlockIndex* pindexNew)
     CheckForkWarningConditions();
 }
 
-void static InvalidBlockFound(CBlockIndex* pindex, const CValidationState& state)
+void InvalidBlockFound(CBlockIndex* pindex, const CValidationState& state)
 {
     int nDoS = 0;
     if (state.IsInvalid(nDoS)) {
@@ -1237,7 +1241,7 @@ void static InvalidBlockFound(CBlockIndex* pindex, const CValidationState& state
     }
 }
 
-void static FlushBlockFile(bool fFinalize = false)
+void FlushBlockFile(bool fFinalize = false)
 {
     LOCK(cs_LastBlockFile);
 
@@ -1260,9 +1264,35 @@ void static FlushBlockFile(bool fFinalize = false)
     }
 }
 
-bool FindUndoPos(CValidationState& state, int nFile, CDiskBlockPos& pos, unsigned int nAddSize);
+bool FindUndoPos(CValidationState& state, int nFile, CDiskBlockPos& pos, unsigned int nAddSize)
+{
+    pos.nFile = nFile;
+
+    LOCK(cs_LastBlockFile);
+
+    unsigned int nNewSize;
+    pos.nPos = vinfoBlockFile[nFile].nUndoSize;
+    nNewSize = vinfoBlockFile[nFile].nUndoSize += nAddSize;
+    setDirtyFileInfo.insert(nFile);
+
+    unsigned int nOldChunks = (pos.nPos + UNDOFILE_CHUNK_SIZE - 1) / UNDOFILE_CHUNK_SIZE;
+    unsigned int nNewChunks = (nNewSize + UNDOFILE_CHUNK_SIZE - 1) / UNDOFILE_CHUNK_SIZE;
+    if (nNewChunks > nOldChunks) {
+        if (CheckDiskSpace(nNewChunks * UNDOFILE_CHUNK_SIZE - pos.nPos)) {
+            FILE* file = OpenUndoFile(pos);
+            if (file) {
+                LogPrintf("Pre-allocating up to position 0x%x in rev%05u.dat\n", nNewChunks * UNDOFILE_CHUNK_SIZE, pos.nFile);
+                AllocateFileRange(file, pos.nPos, nNewChunks * UNDOFILE_CHUNK_SIZE - pos.nPos);
+                fclose(file);
+            }
+        } else
+            return state.Error("out of disk space");
+    }
+
+    return true;
+}
 
-static int64_t nTimeTotal = 0;
+int64_t nTimeTotal = 0;
 
 void VerifyBestBlockIsAtPreviousBlock(const CBlockIndex* pindex, CCoinsViewCache& view)
 {
@@ -1391,6 +1421,8 @@ bool UpdateDBIndicesForNewBlock(
     return true;
 }
 
+} // anonymous namespace
+
 bool ConnectBlock(const CBlock& block, CValidationState& state, CBlockIndex* pindex, CCoinsViewCache& view, bool fJustCheck, bool fAlreadyChecked)
 {
     AssertLockHeld(cs_main);
@@ -2140,34 +2172,6 @@ bool FindBlockPos(CValidationState& state, CDiskBlockPos& pos, unsigned int nAdd
     return true;
 }
 
-bool FindUndoPos(CValidationState& state, int nFile, CDiskBlockPos& pos, unsigned int nAddSize)
-{
-    pos.nFile = nFile;
-
-    LOCK(cs_LastBlockFile);
-
-    unsigned int nNewSize;
-    pos.nPos = vinfoBlockFile[nFile].nUndoSize;
-    nNewSize = vinfoBlockFile[nFile].nUndoSize += nAddSize;
-    setDirtyFileInfo.insert(nFile);
-
-    unsigned int nOldChunks = (pos.nPos + UNDOFILE_CHUNK_SIZE - 1) / UNDOFILE_CHUNK_SIZE;
-    unsigned int nNewChunks = (nNewSize + UNDOFILE_CHUNK_SIZE - 1) / UNDOFILE_CHUNK_SIZE;
-    if (nNewChunks > nOldChunks) {
-        if (CheckDiskSpace(nNewChunks * UNDOFILE_CHUNK_SIZE - pos.nPos)) {
-            FILE* file = OpenUndoFile(pos);
-            if (file) {
-                LogPrintf("Pre-allocating up to position 0x%x in rev%05u.dat\n", nNewChunks * UNDOFILE_CHUNK_SIZE, pos.nFile);
-                AllocateFileRange(file, pos.nPos, nNewChunks * UNDOFILE_CHUNK_SIZE - pos.nPos);
-                fclose(file);
-            }
-        } else
-            return state.Error("out of disk space");
-    }
-
-    return true;
-}
-
 bool CheckBlock(const CBlock& block, CValidationState& state, bool fCheckMerkleRoot)
 {
     // These are checks that are independent of context.
diff --git a/divi/src/masternode-payments.cpp b/divi/src/masternode-payments.cpp
index d3945b493..f231e5329 100644
--- a/divi/src/masternode-payments.cpp
+++ b/divi/src/masternode-payments.cpp
@@ -362,9 +362,7 @@ bool CMasternodePayments::CheckMasternodeWinnerValidity(const CMasternodeSync& m
     /* Make sure that the payee is in our own payment queue near the top.  */
     const std::vector<CMasternode*> mnQueue = GetMasternodePaymentQueue(seedHash, winner.GetHeight());
     for (int i = 0; i < std::min<int>(2 * MNPAYMENTS_SIGNATURES_TOTAL, mnQueue.size()); ++i) {
-        const auto& mn = *mnQueue[i];
-        const CScript mnPayee = GetScriptForDestination(mn.pubKeyCollateralAddress.GetID());
-        if (mnPayee == winner.payee)
+        if (winner.payee == mnQueue[i]->GetPaymentScript())
             return true;
     }
     return false;
@@ -474,21 +472,31 @@ std::string CMasternodeBlockPayees::GetRequiredPaymentsString() const
 {
     LOCK(cs_vecPayments);
 
-    std::string ret = "Unknown";
+    std::ostringstream ret;
+    bool found = false;
 
     for (const auto& payee : vecPayments) {
-        CTxDestination address1;
-        ExtractDestination(payee.scriptPubKey, address1);
-        CBitcoinAddress address2(address1);
+        std::string thisPayee;
 
-        if (ret != "Unknown") {
-            ret += ", " + address2.ToString() + ":" + boost::lexical_cast<std::string>(payee.nVotes);
+        CTxDestination address1;
+        if (ExtractDestination(payee.scriptPubKey, address1)) {
+            const CBitcoinAddress address2(address1);
+            thisPayee = address2.ToString();
         } else {
-            ret = address2.ToString() + ":" + boost::lexical_cast<std::string>(payee.nVotes);
+            thisPayee = HexStr(payee.scriptPubKey);
         }
+
+        if (found)
+            ret << ", ";
+
+        found = true;
+        ret << thisPayee << ":" << payee.nVotes;
     }
 
-    return ret;
+    if (!found)
+        return "Unknown";
+
+    return ret.str();
 }
 
 std::string CMasternodePayments::GetRequiredPaymentsString(const uint256& seedHash) const
@@ -584,7 +592,6 @@ unsigned CMasternodePayments::FindLastPayeePaymentTime(const CMasternode& master
     const CBlockIndex* chainTip = chainActive.Tip();
     if (chainTip == NULL) return 0u;
 
-    CScript mnPayee = GetScriptForDestination(masternode.pubKeyCollateralAddress.GetID());
     unsigned n = 0;
     for (unsigned int i = 1; chainTip && chainTip->nHeight > 0; i++) {
         if (n >= maxBlockDepth) {
@@ -602,7 +609,7 @@ unsigned CMasternodePayments::FindLastPayeePaymentTime(const CMasternode& master
                 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();
             }
         }
@@ -656,7 +663,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
diff --git a/divi/src/masternode-sync.h b/divi/src/masternode-sync.h
index 1ce4a3b33..c15d852e1 100644
--- a/divi/src/masternode-sync.h
+++ b/divi/src/masternode-sync.h
@@ -85,7 +85,7 @@ class CMasternodeSync
     bool MasternodeWinnersListIsSync(CNode* pnode, const int64_t now);
     void Process(bool networkIsRegtest);
     bool IsSynced() const;
-    bool IsMasternodeListSynced() { return RequestedMasternodeAssets > MASTERNODE_SYNC_LIST; }
+    bool IsMasternodeListSynced() const { return RequestedMasternodeAssets > MASTERNODE_SYNC_LIST; }
     void AskForMN(CNode* pnode, const CTxIn& vin) const;
 };
 
diff --git a/divi/src/masternode.cpp b/divi/src/masternode.cpp
index d2391d2c2..db4be5654 100644
--- a/divi/src/masternode.cpp
+++ b/divi/src/masternode.cpp
@@ -6,12 +6,13 @@
 #include "masternode.h"
 
 #include <sync.h>
-#include <Logging.h>
 #include <boost/lexical_cast.hpp>
 #include <timedata.h>
 #include <script/standard.h>
 #include <chainparams.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;
@@ -84,6 +86,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;
@@ -109,6 +112,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);
@@ -128,6 +132,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;
@@ -148,8 +162,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)
@@ -258,11 +271,15 @@ bool CMasternode::IsValidNetAddr() const
             (IsReachable(addr) && addr.IsRoutable());
 }
 
-CMasternodeBroadcast::CMasternodeBroadcast(CService newAddr, CTxIn newVin, CPubKey pubKeyCollateralAddressNew, CPubKey pubKeyMasternodeNew, const MasternodeTier nMasternodeTier, int protocolVersionIn)
+CMasternodeBroadcast::CMasternodeBroadcast(
+    const CService& newAddr, const CTxIn& newVin,
+    const CPubKey& pubKeyCollateralAddressNew, const CScript& rewardScriptIn, const CPubKey& pubKeyMasternodeNew,
+    const MasternodeTier nMasternodeTier, const int protocolVersionIn)
 {
     vin = newVin;
     addr = newAddr;
     pubKeyCollateralAddress = pubKeyCollateralAddressNew;
+    rewardScript = rewardScriptIn;
     pubKeyMasternode = pubKeyMasternodeNew;
     protocolVersion = protocolVersionIn;
     nTier = nMasternodeTier;
@@ -280,10 +297,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 f987234c1..6b29b4b7a 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)
@@ -59,6 +60,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;
@@ -90,6 +95,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
      *  seed hash.  It should be the result of GetBlockHashForScoring of
      *  the target block height.  */
@@ -119,6 +129,7 @@ class CMasternode
         READWRITE(vin);
         READWRITE(addr);
         READWRITE(pubKeyCollateralAddress);
+        READWRITE(rewardScript);
         READWRITE(pubKeyMasternode);
         READWRITE(signature);
         READWRITE(sigTime);
@@ -146,15 +157,20 @@ class CMasternode
 
 class CMasternodeBroadcast : public CMasternode
 {
-public:
-    CMasternodeBroadcast() = default;
+private:
     CMasternodeBroadcast(
-        CService newAddr,
-        CTxIn newVin,
-        CPubKey pubKeyCollateralAddress,
-        CPubKey pubKeyMasternode,
+        const CService& newAddr,
+        const CTxIn& newVin,
+        const CPubKey& pubKeyCollateralAddress,
+        const CScript& rewardScriptIn,
+        const CPubKey& pubKeyMasternode,
         MasternodeTier nMasternodeTier,
         int protocolVersionIn);
+
+    friend class CMasternodeBroadcastFactory;
+
+public:
+    CMasternodeBroadcast() = default;
     CMasternodeBroadcast(const CMasternode& mn);
 
     void Relay() const;
@@ -169,6 +185,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/masternodeconfig.cpp b/divi/src/masternodeconfig.cpp
index 91b9debb9..28667157c 100644
--- a/divi/src/masternodeconfig.cpp
+++ b/divi/src/masternodeconfig.cpp
@@ -23,10 +23,12 @@ boost::filesystem::path GetMasternodeConfigFile()
     if (!pathConfigFile.is_complete()) pathConfigFile = GetDataDir() / pathConfigFile;
     return pathConfigFile;
 }
-void CMasternodeConfig::add(std::string alias, std::string ip, std::string privKey, std::string txHash, std::string outputIndex)
+
+void CMasternodeConfig::add(const std::string& alias, const std::string& ip, const std::string& privKey,
+                            const std::string& txHash, const std::string& outputIndex,
+                            const std::string& rewardAddr)
 {
-    CMasternodeEntry cme(alias, ip, privKey, txHash, outputIndex);
-    entries.push_back(cme);
+    entries.emplace_back(alias, ip, privKey, txHash, outputIndex, rewardAddr);
 }
 
 bool CMasternodeConfig::read(std::string& strErr)
@@ -70,7 +72,12 @@ bool CMasternodeConfig::read(std::string& strErr)
             }
         }
 
-        add(alias, ip, privKey, txHash, outputIndex);
+        /* This might fail if there is no address, but that is fine and we will
+           just leave the string empty in that case.  */
+        std::string rewardAddr;
+        iss >> rewardAddr;
+
+        add(alias, ip, privKey, txHash, outputIndex, rewardAddr);
     }
 
     streamConfig.close();
@@ -94,15 +101,16 @@ CMasternodeConfig::CMasternodeConfig()
 {
     entries = std::vector<CMasternodeEntry>();
 }
+
 const std::vector<CMasternodeConfig::CMasternodeEntry>& CMasternodeConfig::getEntries() const
 {
     return entries;
 }
 
-int CMasternodeConfig::getCount()
+int CMasternodeConfig::getCount() const
 {
     int c = -1;
-    BOOST_FOREACH (CMasternodeEntry e, entries) {
+    for (const auto& e : entries) {
         if (e.getAlias() != "") c++;
     }
     return c;
diff --git a/divi/src/masternodeconfig.h b/divi/src/masternodeconfig.h
index d5ac185d9..7366d14e9 100644
--- a/divi/src/masternodeconfig.h
+++ b/divi/src/masternodeconfig.h
@@ -23,15 +23,20 @@ class CMasternodeConfig
         std::string privKey;
         std::string txHash;
         std::string outputIndex;
+        std::string rewardAddress;
 
     public:
-        CMasternodeEntry(std::string alias, std::string ip, std::string privKey, std::string txHash, std::string outputIndex)
+        CMasternodeEntry(const std::string& alias, const std::string& ip,
+                         const std::string& privKey,
+                         const std::string& txHash, const std::string& outputIndex,
+                         const std::string& rewardAddress)
         {
             this->alias = alias;
             this->ip = ip;
             this->privKey = privKey;
             this->txHash = txHash;
             this->outputIndex = outputIndex;
+            this->rewardAddress = rewardAddress;
         }
 
         const std::string& getAlias() const
@@ -85,15 +90,27 @@ class CMasternodeConfig
         {
             this->ip = ip;
         }
+
+        const std::string& getRewardAddress() const
+        {
+            return rewardAddress;
+        }
+
+        void setRewardAddress(const std::string& addr)
+        {
+            this->rewardAddress = addr;
+        }
     };
 
     CMasternodeConfig();
 
     void clear();
     bool read(std::string& strErr);
-    void add(std::string alias, std::string ip, std::string privKey, std::string txHash, std::string outputIndex);
+    void add(const std::string& alias, const std::string& ip, const std::string& privKey,
+             const std::string& txHash, const std::string& outputIndex,
+             const std::string& rewardAddr);
     const std::vector<CMasternodeEntry>& getEntries() const;
-    int getCount();
+    int getCount() const;
 
 private:
     std::vector<CMasternodeEntry> entries;
diff --git a/divi/src/masternodeman.cpp b/divi/src/masternodeman.cpp
index e2e6485bb..7d50594c5 100644
--- a/divi/src/masternodeman.cpp
+++ b/divi/src/masternodeman.cpp
@@ -204,6 +204,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;
@@ -249,6 +250,12 @@ bool CMasternodeMan::CheckInputsForMasternode(const CMasternodeBroadcast& mnb, i
 }
 bool CMasternodeMan::CheckAndUpdateMasternode(CMasternodeSync& masternodeSynchronization, 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.ToString());
diff --git a/divi/src/rpcmasternode.cpp b/divi/src/rpcmasternode.cpp
index be6621964..0ecca32c3 100644
--- a/divi/src/rpcmasternode.cpp
+++ b/divi/src/rpcmasternode.cpp
@@ -266,7 +266,7 @@ Value setupmasternode(const Array& params, bool fHelp)
     if (ipAndPort.find(':') == std::string::npos)
         ipAndPort += ":" + std::to_string(Params().GetDefaultPort());
 
-    CMasternodeConfig::CMasternodeEntry config(alias,ipAndPort,CBitcoinSecret(masternodeKey).ToString(),txHash,outputIndex);
+    CMasternodeConfig::CMasternodeEntry config(alias,ipAndPort,CBitcoinSecret(masternodeKey).ToString(),txHash,outputIndex, "");
 
     CMasternodeBroadcast mnb;
     std::string errorMsg;
@@ -353,12 +353,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);
@@ -541,6 +542,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 a13b0838a..97f7a9376 100644
--- a/divi/src/test/ActiveMasternode_tests.cpp
+++ b/divi/src/test/ActiveMasternode_tests.cpp
@@ -25,7 +25,7 @@ class ActiveMasternodeTestFixture
 
     void AddDummyConfiguration(CTxIn txIn, CService service)
     {
-        configurations_->add("dummy configuration", service.ToString(), "", txIn.prevout.hash.ToString(), std::to_string(txIn.prevout.n));
+        configurations_->add("dummy configuration", service.ToString(), "", txIn.prevout.hash.ToString(), std::to_string(txIn.prevout.n), "");
     }
 };
 
@@ -98,4 +98,4 @@ BOOST_AUTO_TEST_CASE(willSetMatchingPubkeyForPrivateKey)
     BOOST_CHECK(activeMasternode_->pubKeyMasternode == expectedPubkey);
 }
 
-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;