diff --git a/src/Makefile.am b/src/Makefile.am
index 24ae008afc7..9a071b0031d 100644
--- a/src/Makefile.am
+++ b/src/Makefile.am
@@ -169,7 +169,6 @@ BITCOIN_CORE_H = \
   policy/settings.h \
   pos.h \
   pos_kernel.h \
-  pow.h \
   protocol.h \
   psbt.h \
   random.h \
@@ -290,7 +289,6 @@ libbitcoin_server_a_SOURCES = \
   policy/settings.cpp \
   pos.cpp \
   pos_kernel.cpp \
-  pow.cpp \
   rest.cpp \
   rpc/blockchain.cpp \
   rpc/mining.cpp \
diff --git a/src/bench/duplicate_inputs.cpp b/src/bench/duplicate_inputs.cpp
index 2440341287f..d5d45e42a54 100644
--- a/src/bench/duplicate_inputs.cpp
+++ b/src/bench/duplicate_inputs.cpp
@@ -7,7 +7,7 @@
 #include <coins.h>
 #include <consensus/merkle.h>
 #include <consensus/validation.h>
-#include <pow.h>
+#include <pos.h>
 #include <txmempool.h>
 #include <validation.h>
 
@@ -28,8 +28,8 @@ static void DuplicateInputs(benchmark::State& state)
     LOCK(cs_main);
     CBlockIndex* pindexPrev = ::ChainActive().Tip();
     assert(pindexPrev != nullptr);
-    block.nBits = GetNextWorkRequired(pindexPrev, &block, chainparams.GetConsensus());
-    block.nNonce = 0;
+    block.nBits = pos::GetNextWorkRequired(pindexPrev, &block, chainparams.GetConsensus().pos);
+    // block.nNonce = 0;
     auto nHeight = pindexPrev->nHeight + 1;
 
     // Make a coinbase TX
diff --git a/src/chain.cpp b/src/chain.cpp
index 5520d8149a1..40772206606 100644
--- a/src/chain.cpp
+++ b/src/chain.cpp
@@ -144,7 +144,7 @@ int64_t GetBlockProofEquivalentTime(const CBlockIndex& to, const CBlockIndex& fr
         r = from.nChainWork - to.nChainWork;
         sign = -1;
     }
-    r = r * arith_uint256(params.nPowTargetSpacing) / GetBlockProof(tip);
+    r = r * arith_uint256(params.pos.nTargetSpacing) / GetBlockProof(tip);
     if (r.bits() > 63) {
         return sign * std::numeric_limits<int64_t>::max();
     }
diff --git a/src/chain.h b/src/chain.h
index 26c303c38d8..bd2215c9133 100644
--- a/src/chain.h
+++ b/src/chain.h
@@ -10,6 +10,7 @@
 #include <consensus/params.h>
 #include <flatfile.h>
 #include <primitives/block.h>
+#include <streams.h>
 #include <tinyformat.h>
 #include <uint256.h>
 
@@ -181,11 +182,13 @@ class CBlockIndex
     uint256 hashMerkleRoot;
     uint32_t nTime;
     uint32_t nBits;
-    uint32_t nNonce;
-    boost::optional<CBlockHeader::PoS> proofOfStakeBody;
 
     // proof-of-stake specific fields
+    uint64_t height;
+    uint64_t mintedBlocks;
     uint256 stakeModifier; // hash modifier for proof-of-stake
+    std::vector<unsigned char> sig;
+    CKeyID minter; // memory only
 
     //! (memory only) Sequential id assigned to distinguish order in which blocks are received.
     int32_t nSequenceId;
@@ -209,15 +212,14 @@ class CBlockIndex
         nSequenceId = 0;
         nTimeMax = 0;
 
-        // PoS
-        proofOfStakeBody = boost::optional<CBlockHeader::PoS>{};
-        stakeModifier = uint256{};
-
         nVersion       = 0;
         hashMerkleRoot = uint256();
         nTime          = 0;
         nBits          = 0;
-        nNonce         = 0;
+        stakeModifier  = uint256{};
+        height         = 0;
+        mintedBlocks   = 0;
+        sig            = {};
     }
 
     CBlockIndex()
@@ -233,9 +235,10 @@ class CBlockIndex
         hashMerkleRoot = block.hashMerkleRoot;
         nTime          = block.nTime;
         nBits          = block.nBits;
-        nNonce         = block.nNonce;
+        height         = block.height;
+        mintedBlocks   = block.mintedBlocks;
         stakeModifier  = block.stakeModifier;
-        proofOfStakeBody = block.proofOfStakeBody;
+        sig            = block.sig;
     }
 
     FlatFilePos GetBlockPos() const {
@@ -265,9 +268,10 @@ class CBlockIndex
         block.hashMerkleRoot = hashMerkleRoot;
         block.nTime          = nTime;
         block.nBits          = nBits;
-        block.nNonce         = nNonce;
         block.stakeModifier   = stakeModifier;
-        block.proofOfStakeBody = proofOfStakeBody;
+        block.height         = height;
+        block.mintedBlocks   = mintedBlocks;
+        block.sig            = sig;
         return block;
     }
 
@@ -343,14 +347,16 @@ class CBlockIndex
         return false;
     }
 
-    bool IsProofOfStake() const
-    {
-        return (bool) proofOfStakeBody;
-    }
-
     //! Build the skiplist pointer for this entry.
     void BuildSkip();
 
+    uint256 GetHashToSign() const
+    {
+        CDataStream ss(SER_GETHASH, 0);
+        ss << nVersion << pprev->GetBlockHash() << hashMerkleRoot << nTime << nBits << height << mintedBlocks << stakeModifier;
+        return Hash(ss.begin(), ss.end());
+    }
+
     //! Efficiently find an ancestor of this block.
     CBlockIndex* GetAncestor(int height);
     const CBlockIndex* GetAncestor(int height) const;
@@ -395,18 +401,15 @@ class CDiskBlockIndex : public CBlockIndex
         if (nStatus & BLOCK_HAVE_UNDO)
             READWRITE(VARINT(nUndoPos));
 
-        //PoS serialization
-        CBlockHeader::PoS loc_proofOfStake = proofOfStakeBody ? *proofOfStakeBody : CBlockHeader::PoS{};
-        READWRITE(loc_proofOfStake);
-        proofOfStakeBody = loc_proofOfStake;
-
         // block header
         READWRITE(this->nVersion);
         READWRITE(hashPrev);
         READWRITE(hashMerkleRoot);
         READWRITE(nTime);
         READWRITE(nBits);
-        READWRITE(nNonce);
+        READWRITE(height);
+        READWRITE(mintedBlocks);
+        READWRITE(sig);
     }
 
     uint256 GetBlockHash() const
@@ -417,9 +420,11 @@ class CDiskBlockIndex : public CBlockIndex
         block.hashMerkleRoot  = hashMerkleRoot;
         block.nTime           = nTime;
         block.nBits           = nBits;
-        block.nNonce          = nNonce;
-        block.stakeModifier    = stakeModifier;
-        block.proofOfStakeBody = proofOfStakeBody;
+        block.stakeModifier   = stakeModifier;
+        block.height          = height;
+        block.mintedBlocks    = mintedBlocks;
+        block.sig             = sig;
+
         return block.GetHash();
     }
 
diff --git a/src/chainparams.cpp b/src/chainparams.cpp
index ec66a232261..408e3564c21 100644
--- a/src/chainparams.cpp
+++ b/src/chainparams.cpp
@@ -17,21 +17,23 @@
 #include <boost/algorithm/string/classification.hpp>
 #include <boost/algorithm/string/split.hpp>
 
-static CBlock CreateGenesisBlock(const char* pszTimestamp, const CScript& genesisOutputScript, uint32_t nTime, uint32_t nNonce, uint32_t nBits, int32_t nVersion, const CAmount& genesisReward)
+static CBlock CreateGenesisBlock(const char* pszTimestamp, const CScript& genesisOutputScript, uint32_t nTime, uint32_t nBits, int32_t nVersion, const CAmount& genesisReward)
 {
     CMutableTransaction txNew;
     txNew.nVersion = 1;
     txNew.vin.resize(1);
     txNew.vout.resize(1);
-    txNew.vin[0].scriptSig = CScript() << 486604799 << CScriptNum(4) << std::vector<unsigned char>((const unsigned char*)pszTimestamp, (const unsigned char*)pszTimestamp + strlen(pszTimestamp));
+    txNew.vin[0].scriptSig = CScript() << 0 << 486604799 << CScriptNum(4) << std::vector<unsigned char>((const unsigned char*)pszTimestamp, (const unsigned char*)pszTimestamp + strlen(pszTimestamp));
     txNew.vout[0].nValue = genesisReward;
     txNew.vout[0].scriptPubKey = genesisOutputScript;
 
     CBlock genesis;
-    genesis.nTime    = nTime;
-    genesis.nBits    = nBits;
-    genesis.nNonce   = nNonce;
-    genesis.nVersion = nVersion;
+    genesis.nTime           = nTime;
+    genesis.nBits           = nBits;
+    genesis.nVersion        = nVersion;
+    genesis.height          = 0;
+    genesis.stakeModifier   = uint256S("0");
+    genesis.mintedBlocks    = 0;
     genesis.vtx.push_back(MakeTransactionRef(std::move(txNew)));
     genesis.hashPrevBlock.SetNull();
     genesis.hashMerkleRoot = BlockMerkleRoot(genesis);
@@ -43,17 +45,17 @@ static CBlock CreateGenesisBlock(const char* pszTimestamp, const CScript& genesi
  * transaction cannot be spent since it did not originally exist in the
  * database.
  *
- * CBlock(hash=000000000019d6, ver=1, hashPrevBlock=00000000000000, hashMerkleRoot=4a5e1e, nTime=1231006505, nBits=1d00ffff, nNonce=2083236893, vtx=1)
+ * CBlock(hash=000000000019d6, ver=1, hashPrevBlock=00000000000000, hashMerkleRoot=4a5e1e, nTime=1231006505, nBits=1d00ffff, vtx=1)
  *   CTransaction(hash=4a5e1e, ver=1, vin.size=1, vout.size=1, nLockTime=0)
  *     CTxIn(COutPoint(000000, -1), coinbase 04ffff001d0104455468652054696d65732030332f4a616e2f32303039204368616e63656c6c6f72206f6e206272696e6b206f66207365636f6e64206261696c6f757420666f722062616e6b73)
  *     CTxOut(nValue=50.00000000, scriptPubKey=0x5F1DF16B2B704C8A578D0B)
  *   vMerkleTree: 4a5e1e
  */
-static CBlock CreateGenesisBlock(uint32_t nTime, uint32_t nNonce, uint32_t nBits, int32_t nVersion, const CAmount& genesisReward)
+static CBlock CreateGenesisBlock(uint32_t nTime, uint32_t nBits, int32_t nVersion, const CAmount& genesisReward)
 {
     const char* pszTimestamp = "The Times 03/Jan/2009 Chancellor on brink of second bailout for banks";
     const CScript genesisOutputScript = CScript() << ParseHex("04678afdb0fe5548271967f1a67130b7105cd6a828e03909a67962e0ea1f61deb649f6bc3f4cef38c4f35504e51ec112de5c384df7ba0b8d578a4c702b6bf11d5f") << OP_CHECKSIG;
-    return CreateGenesisBlock(pszTimestamp, genesisOutputScript, nTime, nNonce, nBits, nVersion, genesisReward);
+    return CreateGenesisBlock(pszTimestamp, genesisOutputScript, nTime, nBits, nVersion, genesisReward);
 }
 
 /**
@@ -65,10 +67,10 @@ class CMainParams : public CChainParams {
         strNetworkID = "main";
         consensus.nSubsidyHalvingInterval = 210000;
         consensus.BIP16Exception = uint256S("0x00000000000002dc756eebf4f49723ed8d30cc28a5f108eb94b1ba88ac4f9c22");
-        consensus.BIP34Height = 227931;
-        consensus.BIP34Hash = uint256S("0x000000000000024b89b42a942fe0d9fea3bb44ab7bd1b19115dd6a759c0808b8");
-        consensus.BIP65Height = 388381; // 000000000000000004c2b624ed5d7756c508d90fd0da2c7c679febfa6c4735f0
-        consensus.BIP66Height = 363725; // 00000000000000000379eaa19dce8c9b722d46ae6a57c2f1a988119488b50931
+        consensus.BIP34Height = 0;
+        consensus.BIP34Hash = uint256();
+        consensus.BIP65Height = 0; // 000000000000000004c2b624ed5d7756c508d90fd0da2c7c679febfa6c4735f0
+        consensus.BIP66Height = 0; // 00000000000000000379eaa19dce8c9b722d46ae6a57c2f1a988119488b50931
 
         consensus.pos.diffLimit = uint256S("00000fffffffffffffffffffffffffffffffffffffffffffffffffffffffffff");
         consensus.pos.nTargetTimespan = 14 * 24 * 60 * 60; // two weeks
@@ -80,21 +82,16 @@ class CMainParams : public CChainParams {
 
         consensus.pos.allowMintingWithoutPeers = false; // don't mint if no peers connected
 
-        consensus.CSVHeight = 419328; // 000000000000000004a1b34462cb8aeebd5799177f7a29cf28f2d1961716b5b5
-        consensus.SegwitHeight = 481824; // 0000000000000000001c8018d9cb3b742ef25114f27563e3fc4a1902167f9893
-        consensus.powLimit = uint256S("00000000ffffffffffffffffffffffffffffffffffffffffffffffffffffffff");
-        consensus.nPowTargetTimespan = 14 * 24 * 60 * 60; // two weeks
-        consensus.nPowTargetSpacing = 10 * 60;
-        consensus.fPowAllowMinDifficultyBlocks = false;
-        consensus.fPowNoRetargeting = false;
+        consensus.CSVHeight = 0; // 000000000000000004a1b34462cb8aeebd5799177f7a29cf28f2d1961716b5b5
+        consensus.SegwitHeight = 0; // 0000000000000000001c8018d9cb3b742ef25114f27563e3fc4a1902167f9893
         consensus.nRuleChangeActivationThreshold = 1916; // 95% of 2016
-        consensus.nMinerConfirmationWindow = 2016; // nPowTargetTimespan / nPowTargetSpacing
+        consensus.nMinerConfirmationWindow = 2016; // nTargetTimespan / nTargetSpacing
         consensus.vDeployments[Consensus::DEPLOYMENT_TESTDUMMY].bit = 28;
         consensus.vDeployments[Consensus::DEPLOYMENT_TESTDUMMY].nStartTime = 1199145601; // January 1, 2008
         consensus.vDeployments[Consensus::DEPLOYMENT_TESTDUMMY].nTimeout = 1230767999; // December 31, 2008
 
         // The best chain should have at least this much work.
-        consensus.nMinimumChainWork = uint256S("0x0000000000000000000000000000000000000000051dc8b82f450202ecb3d471");
+        consensus.nMinimumChainWork = uint256S("0x00");
 
         // By default assume that the signatures in ancestors of this block are valid.
         consensus.defaultAssumeValid = uint256S("0x0000000000000000000f1c54590ee18d15ec70e68c8cd4cfbadb1b4f11697eee"); //563378
@@ -113,10 +110,11 @@ class CMainParams : public CChainParams {
         m_assumed_blockchain_size = 240;
         m_assumed_chain_state_size = 3;
 
-        genesis = CreateGenesisBlock(1231006505, 2083236893, 0x1d00ffff, 1, 50 * COIN);
+        genesis = CreateGenesisBlock(1569396815, 0x1e0fffff, 1, 50 * COIN);
+
         consensus.hashGenesisBlock = genesis.GetHash();
-        assert(consensus.hashGenesisBlock == uint256S("0x000000000019d6689c085ae165831e934ff763ae46a2a6c172b3f1b60a8ce26f"));
-        assert(genesis.hashMerkleRoot == uint256S("0x4a5e1e4baab89f3a32518a88c31bc87f618f76673e2cc77ab2127b7afdeda33b"));
+        assert(consensus.hashGenesisBlock == uint256S("0xc0f410a59e9aa22afd67ee4671d41c2e3135c0efc589446e4b393cc534d178ac"));
+        assert(genesis.hashMerkleRoot == uint256S("0x800c7581a09c96d98bdad848db8fc027e8869d28d890ca21f6c25124baf53afe"));
 
         // Note that of those which support the service bits prefix, most only support a subset of
         // possible options.
@@ -166,9 +164,9 @@ class CMainParams : public CChainParams {
 
         chainTxData = ChainTxData{
             // Data from rpc: getchaintxstats 4096 0000000000000000000f1c54590ee18d15ec70e68c8cd4cfbadb1b4f11697eee
-            /* nTime    */ 1550374134,
-            /* nTxCount */ 383732546,
-            /* dTxRate  */ 3.685496590998308
+            /* nTime    */ 1569396815,
+            /* nTxCount */ 0,
+            /* dTxRate  */ 0
         };
     }
 };
@@ -182,10 +180,10 @@ class CTestNetParams : public CChainParams {
         strNetworkID = "test";
         consensus.nSubsidyHalvingInterval = 210000;
         consensus.BIP16Exception = uint256S("0x00000000dd30457c001f4095d208cc1296b0eed002427aa599874af7a432b105");
-        consensus.BIP34Height = 21111;
-        consensus.BIP34Hash = uint256S("0x0000000023b3a96d3484e5abb3755c413e7d41500f8e2a5c3f0dd01299cd8ef8");
-        consensus.BIP65Height = 581885; // 00000000007f6655f22f98e72ed80d8b06dc761d5da09df0fa1dc4be4f861eb6
-        consensus.BIP66Height = 330776; // 000000002104c8c45e99a8853285a3b592602a3ccde2b832481da85e9e4ba182
+        consensus.BIP34Height = 0;
+        consensus.BIP34Hash = uint256();
+        consensus.BIP65Height = 0; // 00000000007f6655f22f98e72ed80d8b06dc761d5da09df0fa1dc4be4f861eb6
+        consensus.BIP66Height = 0; // 000000002104c8c45e99a8853285a3b592602a3ccde2b832481da85e9e4ba182
 
         consensus.pos.diffLimit = uint256S("00000fffffffffffffffffffffffffffffffffffffffffffffffffffffffffff");
         consensus.pos.nTargetTimespan = 14 * 24 * 60 * 60; // two weeks
@@ -195,23 +193,18 @@ class CTestNetParams : public CChainParams {
 
         consensus.pos.coinstakeMaturity = 100;
 
-        consensus.pos.allowMintingWithoutPeers = false; // don't mint if no peers connected
+        consensus.pos.allowMintingWithoutPeers = true;
 
-        consensus.CSVHeight = 770112; // 00000000025e930139bac5c6c31a403776da130831ab85be56578f3fa75369bb
-        consensus.SegwitHeight = 834624; // 00000000002b980fcd729daaa248fd9316a5200e9b367f4ff2c42453e84201ca
-        consensus.powLimit = uint256S("00000000ffffffffffffffffffffffffffffffffffffffffffffffffffffffff");
-        consensus.nPowTargetTimespan = 14 * 24 * 60 * 60; // two weeks
-        consensus.nPowTargetSpacing = 10 * 60;
-        consensus.fPowAllowMinDifficultyBlocks = true;
-        consensus.fPowNoRetargeting = false;
+        consensus.CSVHeight = 0; // 00000000025e930139bac5c6c31a403776da130831ab85be56578f3fa75369bb
+        consensus.SegwitHeight = 0; // 00000000002b980fcd729daaa248fd9316a5200e9b367f4ff2c42453e84201ca
         consensus.nRuleChangeActivationThreshold = 1512; // 75% for testchains
-        consensus.nMinerConfirmationWindow = 2016; // nPowTargetTimespan / nPowTargetSpacing
+        consensus.nMinerConfirmationWindow = 2016; // nTargetTimespan / nTargetSpacing
         consensus.vDeployments[Consensus::DEPLOYMENT_TESTDUMMY].bit = 28;
         consensus.vDeployments[Consensus::DEPLOYMENT_TESTDUMMY].nStartTime = 1199145601; // January 1, 2008
         consensus.vDeployments[Consensus::DEPLOYMENT_TESTDUMMY].nTimeout = 1230767999; // December 31, 2008
 
         // The best chain should have at least this much work.
-        consensus.nMinimumChainWork = uint256S("0x00000000000000000000000000000000000000000000007dbe94253893cbd463");
+        consensus.nMinimumChainWork = uint256S("0x00");
 
         // By default assume that the signatures in ancestors of this block are valid.
         consensus.defaultAssumeValid = uint256S("0x0000000000000037a8cd3e06cd5edbfe9dd1dbcc5dacab279376ef7cfc2b4c75"); //1354312
@@ -225,10 +218,11 @@ class CTestNetParams : public CChainParams {
         m_assumed_blockchain_size = 30;
         m_assumed_chain_state_size = 2;
 
-        genesis = CreateGenesisBlock(1296688602, 414098458, 0x1d00ffff, 1, 50 * COIN);
+        genesis = CreateGenesisBlock(1569396815, 0x1e0fffff, 1, 50 * COIN);
         consensus.hashGenesisBlock = genesis.GetHash();
-        assert(consensus.hashGenesisBlock == uint256S("0x000000000933ea01ad0ee984209779baaec3ced90fa3f408719526f8d77f4943"));
-        assert(genesis.hashMerkleRoot == uint256S("0x4a5e1e4baab89f3a32518a88c31bc87f618f76673e2cc77ab2127b7afdeda33b"));
+
+        assert(consensus.hashGenesisBlock == uint256S("0xc0f410a59e9aa22afd67ee4671d41c2e3135c0efc589446e4b393cc534d178ac"));
+        assert(genesis.hashMerkleRoot == uint256S("0x800c7581a09c96d98bdad848db8fc027e8869d28d890ca21f6c25124baf53afe"));
 
         vFixedSeeds.clear();
         vSeeds.clear();
@@ -261,9 +255,9 @@ class CTestNetParams : public CChainParams {
 
         chainTxData = ChainTxData{
             // Data from rpc: getchaintxstats 4096 0000000000000037a8cd3e06cd5edbfe9dd1dbcc5dacab279376ef7cfc2b4c75
-            /* nTime    */ 1531929919,
-            /* nTxCount */ 19438708,
-            /* dTxRate  */ 0.626
+            /* nTime    */ 1569396815,
+            /* nTxCount */ 0,
+            /* dTxRate  */ 0
         };
     }
 };
@@ -277,10 +271,10 @@ class CRegTestParams : public CChainParams {
         strNetworkID = "regtest";
         consensus.nSubsidyHalvingInterval = 150;
         consensus.BIP16Exception = uint256();
-        consensus.BIP34Height = 500; // BIP34 activated on regtest (Used in functional tests)
+        consensus.BIP34Height = 0; // BIP34 activated on regtest (Used in functional tests)
         consensus.BIP34Hash = uint256();
-        consensus.BIP65Height = 1351; // BIP65 activated on regtest (Used in functional tests)
-        consensus.BIP66Height = 1251; // BIP66 activated on regtest (Used in functional tests)
+        consensus.BIP65Height = 0; // BIP65 activated on regtest (Used in functional tests)
+        consensus.BIP66Height = 0; // BIP66 activated on regtest (Used in functional tests)
         consensus.pos.diffLimit = uint256S("00000fffffffffffffffffffffffffffffffffffffffffffffffffffffffffff");
         consensus.pos.nTargetTimespan = 14 * 24 * 60 * 60; // two weeks
         consensus.pos.nTargetSpacing = 10 * 60; // 10 minutes
@@ -291,13 +285,8 @@ class CRegTestParams : public CChainParams {
 
         consensus.pos.allowMintingWithoutPeers = false; // don't mint if no peers connected
 
-        consensus.CSVHeight = 432; // CSV activated on regtest (Used in rpc activation tests)
+        consensus.CSVHeight = 0; // CSV activated on regtest (Used in rpc activation tests)
         consensus.SegwitHeight = 0; // SEGWIT is always activated on regtest unless overridden
-        consensus.powLimit = uint256S("7fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff");
-        consensus.nPowTargetTimespan = 14 * 24 * 60 * 60; // two weeks
-        consensus.nPowTargetSpacing = 10 * 60;
-        consensus.fPowAllowMinDifficultyBlocks = true;
-        consensus.fPowNoRetargeting = true;
         consensus.nRuleChangeActivationThreshold = 108; // 75% for testchains
         consensus.nMinerConfirmationWindow = 144; // Faster than normal for regtest (144 instead of 2016)
         consensus.vDeployments[Consensus::DEPLOYMENT_TESTDUMMY].bit = 28;
@@ -321,10 +310,11 @@ class CRegTestParams : public CChainParams {
 
         UpdateActivationParametersFromArgs(args);
 
-        genesis = CreateGenesisBlock(1296688602, 2, 0x207fffff, 1, 50 * COIN);
+        genesis = CreateGenesisBlock(1569396815, 0x1e0fffff, 1, 50 * COIN);
         consensus.hashGenesisBlock = genesis.GetHash();
-        assert(consensus.hashGenesisBlock == uint256S("0x0f9188f13cb7b2c71f2a335e3a4fc328bf5beb436012afca590b1a11466e2206"));
-        assert(genesis.hashMerkleRoot == uint256S("0x4a5e1e4baab89f3a32518a88c31bc87f618f76673e2cc77ab2127b7afdeda33b"));
+
+        assert(consensus.hashGenesisBlock == uint256S("0xc0f410a59e9aa22afd67ee4671d41c2e3135c0efc589446e4b393cc534d178ac"));
+        assert(genesis.hashMerkleRoot == uint256S("0x800c7581a09c96d98bdad848db8fc027e8869d28d890ca21f6c25124baf53afe"));
 
         vFixedSeeds.clear(); //!< Regtest mode doesn't have any fixed seeds.
         vSeeds.clear();      //!< Regtest mode doesn't have any DNS seeds.
diff --git a/src/chainparams.h b/src/chainparams.h
index 8f1d27e03cd..90e94c6102f 100644
--- a/src/chainparams.h
+++ b/src/chainparams.h
@@ -74,7 +74,7 @@ class CChainParams
     /** Minimum free space (in GB) needed for data directory when pruned; Does not include prune target*/
     uint64_t AssumedChainStateSize() const { return m_assumed_chain_state_size; }
     /** Whether it is possible to mine blocks on demand (no retargeting) */
-    bool MineBlocksOnDemand() const { return consensus.fPowNoRetargeting; }
+    bool MineBlocksOnDemand() const { return consensus.pos.fNoRetargeting; }
     /** Return the BIP70 network string (main, test or regtest) */
     std::string NetworkIDString() const { return strNetworkID; }
     /** Return the list of hostnames to look up for DNS seeds */
diff --git a/src/consensus/params.h b/src/consensus/params.h
index c903b48a1df..b969d557efa 100644
--- a/src/consensus/params.h
+++ b/src/consensus/params.h
@@ -64,6 +64,7 @@ struct Params {
      * BIP 16 exception blocks. */
     int SegwitHeight;
 
+    /** Proof of stake parameters */
     struct PoS {
         uint256 diffLimit;
         int64_t nTargetTimespan;
@@ -81,19 +82,13 @@ struct Params {
 
     /**
      * Minimum blocks including miner confirmation of the total of 2016 blocks in a retargeting period,
-     * (nPowTargetTimespan / nPowTargetSpacing) which is also used for BIP9 deployments.
+     * (nTargetTimespan / nTargetSpacing) which is also used for BIP9 deployments.
      * Examples: 1916 for 95%, 1512 for testchains.
      */
     uint32_t nRuleChangeActivationThreshold;
     uint32_t nMinerConfirmationWindow;
     BIP9Deployment vDeployments[MAX_VERSION_BITS_DEPLOYMENTS];
-    /** Proof of work parameters */
-    uint256 powLimit;
-    bool fPowAllowMinDifficultyBlocks;
-    bool fPowNoRetargeting;
-    int64_t nPowTargetSpacing;
-    int64_t nPowTargetTimespan;
-    int64_t DifficultyAdjustmentInterval() const { return nPowTargetTimespan / nPowTargetSpacing; }
+
     uint256 nMinimumChainWork;
     uint256 defaultAssumeValid;
 };
diff --git a/src/init.cpp b/src/init.cpp
index 042335b8e74..23c47880282 100644
--- a/src/init.cpp
+++ b/src/init.cpp
@@ -24,6 +24,7 @@
 #include <index/txindex.h>
 #include <interfaces/chain.h>
 #include <key.h>
+#include <key_io.h>
 #include <miner.h>
 #include <net.h>
 #include <net_permissions.h>
@@ -54,6 +55,7 @@
 #include <validation.h>
 #include <validationinterface.h>
 #include <walletinitinterface.h>
+#include <wallet/wallet.h>
 
 #include <stdint.h>
 #include <stdio.h>
@@ -1823,5 +1825,55 @@ bool AppInitMain(InitInterfaces& interfaces)
         g_banman->DumpBanlist();
     }, DUMP_BANS_INTERVAL * 1000);
 
+    // ********************************************************* Step 14: start minter thread
+    pos::ThreadStaker::Args stakerParams{};
+    {
+        CKey key;
+        std::vector<std::shared_ptr<CWallet>> wallets = GetWallets();
+        if (wallets.size() == 0) {
+            LogPrintf("Warning! wallets not found");
+            return true;
+        }
+        std::shared_ptr<CWallet> defaultWallet = wallets[0];
+
+        CTxDestination destination;
+
+        std::string minterAddress = gArgs.GetArg("-minterAddress", "");
+        if (minterAddress != "") {
+            destination = DecodeDestination(minterAddress);
+            if (!IsValidDestination(destination)) {
+                LogPrintf("Error: coinstake destination is invalid");
+                return false;
+            }
+        } else {
+            std::string strErr;
+            if(!defaultWallet->GetNewDestination(OutputType::LEGACY, "", destination, strErr)) {
+                LogPrintf("%s\n", strErr);
+                return false;
+            }
+        }
+
+        CScript coinbaseScript = GetScriptForDestination(destination);
+        CKey minterKey;
+        if (!defaultWallet->GetKey(CKeyID(*boost::get<PKHash>(&destination)), minterKey)) {
+            LogPrintf("Error: private key not found");
+            return false;
+        }
+
+        stakerParams.coinbaseScript = coinbaseScript;
+        stakerParams.minterKey = minterKey;
+    }
+
+    // Mint proof-of-stake blocks in background
+    threadGroup.create_thread([=]() {
+        TraceThread("CoinStaker", [=]() {
+            // Fill Staker Args
+
+            // Run ThreadStaker
+            pos::ThreadStaker threadStaker{};
+            threadStaker(stakerParams, chainparams);
+        });
+    });
+
     return true;
 }
diff --git a/src/logging.h b/src/logging.h
index 75cd5353c0e..42e230853ac 100644
--- a/src/logging.h
+++ b/src/logging.h
@@ -54,6 +54,7 @@ namespace BCLog {
         COINDB      = (1 << 18),
         QT          = (1 << 19),
         LEVELDB     = (1 << 20),
+        STAKING     = (1 << 21),
         ALL         = ~(uint32_t)0,
     };
 
diff --git a/src/miner.cpp b/src/miner.cpp
index 63ed457ca2d..9579f7b7f7f 100644
--- a/src/miner.cpp
+++ b/src/miner.cpp
@@ -13,9 +13,10 @@
 #include <consensus/merkle.h>
 #include <consensus/tx_verify.h>
 #include <consensus/validation.h>
+#include <net.h>
 #include <policy/feerate.h>
 #include <policy/policy.h>
-#include <pow.h>
+#include <pos.h>
 #include <pos_kernel.h>
 #include <primitives/transaction.h>
 #include <script/standard.h>
@@ -37,8 +38,8 @@ int64_t UpdateTime(CBlockHeader* pblock, const Consensus::Params& consensusParam
         pblock->nTime = nNewTime;
 
     // Updating time can change work required on testnet:
-    if (consensusParams.fPowAllowMinDifficultyBlocks)
-        pblock->nBits = GetNextWorkRequired(pindexPrev, pblock, consensusParams);
+    if (consensusParams.pos.fAllowMinDifficultyBlocks)
+        pblock->nBits = pos::GetNextWorkRequired(pindexPrev, pblock, consensusParams.pos);
 
     return nNewTime - nOldTime;
 }
@@ -161,8 +162,7 @@ std::unique_ptr<CBlockTemplate> BlockAssembler::CreateNewBlock(const CScript& sc
     // Fill in header
     pblock->hashPrevBlock  = pindexPrev->GetBlockHash();
     UpdateTime(pblock, chainparams.GetConsensus(), pindexPrev);
-    pblock->nBits          = GetNextWorkRequired(pindexPrev, pblock, chainparams.GetConsensus());
-    pblock->nNonce         = 0;
+    pblock->nBits          = pos::GetNextWorkRequired(pindexPrev, pblock, chainparams.GetConsensus().pos);
     pblock->stakeModifier = uint256{}; // SS
 
     pblocktemplate->vTxSigOpsCost[0] = WITNESS_SCALE_FACTOR * GetLegacySigOpCount(*pblock->vtx[0]);
@@ -446,3 +446,223 @@ void IncrementExtraNonce(CBlock* pblock, const CBlockIndex* pindexPrev, unsigned
     pblock->vtx[0] = MakeTransactionRef(std::move(txCoinbase));
     pblock->hashMerkleRoot = BlockMerkleRoot(*pblock);
 }
+
+namespace pos {
+
+class Staker {
+private:
+    std::chrono::system_clock::time_point nLastSystemTime;
+    std::chrono::steady_clock::time_point nLastSteadyTime;
+
+    int64_t nLastCoinStakeSearchTime = GetAdjustedTime() - 60;
+
+public:
+    enum class Status {
+        error,
+        initWaiting,
+        stakeWaiting,
+        minted,
+    };
+
+    Status stake(CChainParams chainparams, const ThreadStaker::Args& args) {
+        if (!chainparams.GetConsensus().pos.allowMintingWithoutPeers) {
+            if(!g_connman)
+                throw std::runtime_error("Error: Peer-to-peer functionality missing or disabled");
+
+            if (!chainparams.GetConsensus().pos.allowMintingWithoutPeers && g_connman->GetNodeCount(CConnman::CONNECTIONS_ALL) == 0)
+                return Status::initWaiting;
+        }
+
+        if (nLastSystemTime.time_since_epoch().count() != 0 && nLastSteadyTime.time_since_epoch().count() != 0) {
+            using namespace std::chrono;
+            const auto systemNow = system_clock::now();
+            const auto steadyNow = steady_clock::now();
+            const auto nSystemClockDifference = duration_cast<milliseconds>(systemNow - nLastSystemTime);
+            const auto nSteadyClockDifference = duration_cast<milliseconds>(steadyNow - nLastSteadyTime);
+
+            if(std::abs((nSystemClockDifference - nSteadyClockDifference).count()) > 1000) { //1s
+                //LogPrintf("*** System clock change detected. Staking will be paused until the clock is synced again.\n");
+                // TODO: call a NTP syncing routine
+                //return Status::initWaiting;
+            }
+        }
+
+        nLastSystemTime = std::chrono::system_clock::now();
+        nLastSteadyTime = std::chrono::steady_clock::now();
+
+        bool minted = false;
+
+        CBlockIndex* tip = getTip();
+
+        withSearchInterval([&](int64_t coinstakeTime, int64_t nSearchInterval) {
+            //
+            // Create block template
+            //
+            std::unique_ptr<CBlockTemplate> pblocktemplate(BlockAssembler(chainparams).CreateNewBlock(args.coinbaseScript));
+            if (!pblocktemplate.get()) {
+                throw std::runtime_error("Error in WalletStaker: Keypool ran out, please call keypoolrefill before restarting the staking thread");
+            }
+            std::shared_ptr<CBlock> pblock = std::make_shared<CBlock>(pblocktemplate->block);
+
+            LogPrint(BCLog::STAKING, "Running Staker with %u common transactions in block (%u bytes)\n", pblock->vtx.size() - 1,
+                     ::GetSerializeSize(*pblock, PROTOCOL_VERSION));
+
+            // find matching Hash
+            pblock->height = tip->nHeight + 1;
+            pblock->mintedBlocks = 0; // TODO: (SS) rewrite "0" to actual master nodes mintedBlocks
+            pblock->stakeModifier = pos::ComputeStakeModifier(tip->stakeModifier, args.minterKey.GetPubKey().GetID());
+
+            bool found = false;
+            for (uint32_t t = 0; t < nSearchInterval; t++) {
+                boost::this_thread::interruption_point();
+
+                pblock->nTime = ((uint32_t)coinstakeTime - t);
+
+                if (pos::CheckKernelHash(pblock->stakeModifier, pblock->nBits,  (int64_t) pblock->nTime, chainparams.GetConsensus(), pmasternodesview.get()).hashOk) {
+                    LogPrint(BCLog::STAKING, "MakeStake: kernel found\n");
+
+                    found = true;
+                    break;
+                }
+            }
+
+            if (!found) {
+                return;
+            }
+
+            //
+            // Trying to sign a block
+            //
+            auto err = SignPosBlock(pblock, args.minterKey);
+            if (err) {
+                LogPrint(BCLog::STAKING, "SignPosBlock(): %s \n", *err);
+                return;
+            }
+
+            //
+            // Final checks
+            //
+            err = CheckSignedBlock(pblock, tip, chainparams);
+            if (err) {
+                LogPrint(BCLog::STAKING, "CheckSignedBlock(): %s \n", *err);
+                return;
+            }
+
+            if (!ProcessNewBlock(chainparams, pblock, true, nullptr)) {
+                LogPrintf("PoS block was checked, but wasn't accepted by ProcessNewBlock\n");
+                return;
+            }
+
+            minted = true;
+        });
+
+        return minted ? Status::minted : Status::stakeWaiting;
+    }
+
+private:
+    CBlockIndex* getTip() {
+        LOCK(cs_main);
+        return ::ChainActive().Tip();
+    }
+
+    template <typename F>
+    bool withSearchInterval(F&& f) {
+        const int64_t nTime = GetAdjustedTime();
+
+        if (nTime > nLastCoinStakeSearchTime) {
+            f(nTime, nTime - nLastCoinStakeSearchTime);
+            nLastCoinStakeSearchTime = nTime;
+            return true;
+        }
+        return false;
+    }
+
+    boost::optional<std::string> SignPosBlock(std::shared_ptr<CBlock> pblock, const CKey &key) {
+        // if we are trying to sign a signed proof-of-stake block
+        if (!pblock->sig.empty()) {
+            throw std::logic_error{"Only non-complete PoS block templates are accepted"};
+        }
+
+        // coinstakeTx
+        CMutableTransaction coinstakeTx{*pblock->vtx[0]};
+
+        // Update coinstakeTx after signing
+        pblock->vtx[0] = MakeTransactionRef(coinstakeTx);
+
+        pblock->hashMerkleRoot = BlockMerkleRoot(*pblock);
+
+        bool signingRes = key.SignCompact(pblock->GetHashToSign(), pblock->sig);
+        if (!signingRes) {
+            return {std::string{} + "Block signing error"};
+        }
+
+        return {};
+    }
+
+    boost::optional<std::string> CheckSignedBlock(const std::shared_ptr<CBlock>& pblock, const CBlockIndex* pindexPrev, const CChainParams& chainparams) {
+        uint256 hashBlock = pblock->GetHash();
+
+        // verify hash target and signature of coinstake tx
+        if (!pos::CheckProofOfStake(*(CBlockHeader*)pblock.get(), pindexPrev,  chainparams.GetConsensus(), pmasternodesview.get()))
+            return {std::string{} + "proof-of-stake checking failed"};
+
+        LogPrint(BCLog::STAKING, "new proof-of-stake block found hash: %s\n", hashBlock.GetHex());
+
+        // Found a solution
+        if (pblock->hashPrevBlock != getTip()->GetBlockHash())
+            return {std::string{} + "minted block is stale"};
+
+        return {};
+    }
+};
+
+int32_t ThreadStaker::operator()(ThreadStaker::Args args, CChainParams chainparams) {
+    Staker staker{};
+    int32_t nMinted = 0;
+    int32_t nTried = 0;
+
+    auto trying = [&]() {
+        return args.nMaxTries == -1 || nTried < args.nMaxTries;
+    };
+
+    auto notDone = [&]() {
+        return args.nMint == -1 || nMinted < args.nMint;
+    };
+
+    while (true) {
+        boost::this_thread::interruption_point();
+
+        try {
+            Staker::Status status = staker.stake(chainparams, args);
+            if (status == Staker::Status::error) {
+                LogPrintf("ThreadStaker terminated due to a staking error\n");
+                return nMinted;
+            }
+            if (status == Staker::Status::minted) {
+                LogPrintf("ThreadStaker minted a block!\n");
+                nMinted++;
+            }
+            if (status == Staker::Status::initWaiting) {
+                LogPrintf("ThreadStaker: initial waiting\n");
+            }
+            if (status == Staker::Status::stakeWaiting) {
+                LogPrint(BCLog::STAKING, "Staked, but no kernel found yet\n");
+            }
+        }
+        catch (const std::runtime_error &e) {
+            LogPrintf("ThreadStaker runtime error: %s\n", e.what());
+            return nMinted;
+        }
+
+        nTried++;
+        if (trying() && notDone()) {
+            std::this_thread::sleep_for(std::chrono::milliseconds(900));
+        } else {
+            break;
+        }
+    }
+
+    return nMinted;
+}
+
+}
diff --git a/src/miner.h b/src/miner.h
index 7c4c455072e..3526f79041b 100644
--- a/src/miner.h
+++ b/src/miner.h
@@ -8,6 +8,7 @@
 
 #include <optional.h>
 #include <primitives/block.h>
+#include <key.h>
 #include <txmempool.h>
 #include <validation.h>
 
@@ -202,4 +203,26 @@ class BlockAssembler
 void IncrementExtraNonce(CBlock* pblock, const CBlockIndex* pindexPrev, unsigned int& nExtraNonce);
 int64_t UpdateTime(CBlockHeader* pblock, const Consensus::Params& consensusParams, const CBlockIndex* pindexPrev);
 
+namespace pos {
+
+// The main staking routine.
+// Creates stakes using CWallet API, creates PoS kernels and mints blocks.
+// Uses Args.getWallets() to receive and update wallets list.
+    class ThreadStaker {
+    public:
+
+        struct Args {
+            int32_t nMint = -1;
+            int64_t nMaxTries = -1;
+            CScript coinbaseScript = CScript();
+            CKey minterKey = CKey();
+        };
+
+        /// always forward by value to avoid dangling pointers
+        /// @return number of minted blocks
+        int32_t operator()(Args stakerParams, CChainParams chainparams);
+    };
+
+}
+
 #endif // BITCOIN_MINER_H
diff --git a/src/net_processing.cpp b/src/net_processing.cpp
index 520dfcbb66a..a4676ed2dc7 100644
--- a/src/net_processing.cpp
+++ b/src/net_processing.cpp
@@ -577,12 +577,12 @@ static bool TipMayBeStale(const Consensus::Params &consensusParams) EXCLUSIVE_LO
     if (g_last_tip_update == 0) {
         g_last_tip_update = GetTime();
     }
-    return g_last_tip_update < GetTime() - consensusParams.nPowTargetSpacing * 3 && mapBlocksInFlight.empty();
+    return g_last_tip_update < GetTime() - consensusParams.pos.nTargetSpacing * 3 && mapBlocksInFlight.empty();
 }
 
 static bool CanDirectFetch(const Consensus::Params &consensusParams) EXCLUSIVE_LOCKS_REQUIRED(cs_main)
 {
-    return ::ChainActive().Tip()->GetBlockTime() > GetAdjustedTime() - consensusParams.nPowTargetSpacing * 20;
+    return ::ChainActive().Tip()->GetBlockTime() > GetAdjustedTime() - consensusParams.pos.nTargetSpacing * 20;
 }
 
 static bool PeerHasHeader(CNodeState *state, const CBlockIndex *pindex) EXCLUSIVE_LOCKS_REQUIRED(cs_main)
@@ -2333,7 +2333,7 @@ bool static ProcessMessage(CNode* pfrom, const std::string& strCommand, CDataStr
             }
             // If pruning, don't inv blocks unless we have on disk and are likely to still have
             // for some reasonable time window (1 hour) that block relay might require.
-            const int nPrunedBlocksLikelyToHave = MIN_BLOCKS_TO_KEEP - 3600 / chainparams.GetConsensus().nPowTargetSpacing;
+            const int nPrunedBlocksLikelyToHave = MIN_BLOCKS_TO_KEEP - 3600 / chainparams.GetConsensus().pos.nTargetSpacing;
             if (fPruneMode && (!(pindex->nStatus & BLOCK_HAVE_DATA) || pindex->nHeight <= ::ChainActive().Tip()->nHeight - nPrunedBlocksLikelyToHave))
             {
                 LogPrint(BCLog::NET, " getblocks stopping, pruned or too old block at %d %s\n", pindex->nHeight, pindex->GetBlockHash().ToString());
@@ -3618,7 +3618,7 @@ bool PeerLogicValidation::SendMessages(CNode* pto)
             // Only actively request headers from a single peer, unless we're close to today.
             if ((nSyncStarted == 0 && fFetch) || pindexBestHeader->GetBlockTime() > GetAdjustedTime() - 24 * 60 * 60) {
                 state.fSyncStarted = true;
-                state.nHeadersSyncTimeout = GetTimeMicros() + HEADERS_DOWNLOAD_TIMEOUT_BASE + HEADERS_DOWNLOAD_TIMEOUT_PER_HEADER * (GetAdjustedTime() - pindexBestHeader->GetBlockTime())/(consensusParams.nPowTargetSpacing);
+                state.nHeadersSyncTimeout = GetTimeMicros() + HEADERS_DOWNLOAD_TIMEOUT_BASE + HEADERS_DOWNLOAD_TIMEOUT_PER_HEADER * (GetAdjustedTime() - pindexBestHeader->GetBlockTime())/(consensusParams.pos.nTargetSpacing);
                 nSyncStarted++;
                 const CBlockIndex *pindexStart = pindexBestHeader;
                 /* If possible, start at the block preceding the currently
@@ -3933,7 +3933,7 @@ bool PeerLogicValidation::SendMessages(CNode* pto)
         if (state.vBlocksInFlight.size() > 0) {
             QueuedBlock &queuedBlock = state.vBlocksInFlight.front();
             int nOtherPeersWithValidatedDownloads = nPeersWithValidatedDownloads - (state.nBlocksInFlightValidHeaders > 0);
-            if (nNow > state.nDownloadingSince + consensusParams.nPowTargetSpacing * (BLOCK_DOWNLOAD_TIMEOUT_BASE + BLOCK_DOWNLOAD_TIMEOUT_PER_PEER * nOtherPeersWithValidatedDownloads)) {
+            if (nNow > state.nDownloadingSince + consensusParams.pos.nTargetSpacing * (BLOCK_DOWNLOAD_TIMEOUT_BASE + BLOCK_DOWNLOAD_TIMEOUT_PER_PEER * nOtherPeersWithValidatedDownloads)) {
                 LogPrintf("Timeout downloading block %s from peer=%d, disconnecting\n", queuedBlock.hash.ToString(), pto->GetId());
                 pto->fDisconnect = true;
                 return true;
diff --git a/src/pos.cpp b/src/pos.cpp
index ccbe7bc5201..83b2b5bb58c 100644
--- a/src/pos.cpp
+++ b/src/pos.cpp
@@ -1,128 +1,124 @@
 #include <pos.h>
 #include <pos_kernel.h>
-#include <pow.h>
 #include <chain.h>
 #include <validation.h>
-
+#include <key.h>
 #include <wallet/wallet.h>
 #include <txdb.h>
 
-static bool CheckStakeModifier(const CBlockIndex* pindexPrev, const CBlock& block, const Consensus::Params& params) {
-    if (block.hashPrevBlock.IsNull())
-        return block.stakeModifier.IsNull();
-
-        return block.stakeModifier == pos::ComputeStakeModifier_PoS(pindexPrev->stakeModifier,
-                                                                    block.proofOfStakeBody->coinstakePrevout);
-}
+std::unique_ptr<CMasternodesView> pmasternodesview; // TODO: (SS) Change to real
 
-bool CheckBlockProof_headerOnly(const CBlockHeader& block, const Consensus::Params& params) {
-    return pos::CheckProofOfStake_headerOnly(block, params);
-}
+namespace pos {
+static bool CheckStakeModifier(const CBlockIndex* pindexPrev, const CBlockHeader& blockHeader) {
+    if (blockHeader.hashPrevBlock.IsNull())
+        return blockHeader.stakeModifier.IsNull();
 
-bool CheckBlockProof(const CBlockIndex* pindexPrev, const CBlock& block, CCoinsViewCache& view,
-                     const Consensus::Params& params) {
-    if (!CheckStakeModifier(pindexPrev, block, params)) {
+    CKeyID key;
+    if (!blockHeader.ExtractMinterKey(key)) {
+        LogPrintf("CheckStakeModifier: Can't extract minter key\n");
         return false;
     }
 
-    return pos::CheckProofOfStake(pindexPrev, block, view, params);
-
+    return blockHeader.stakeModifier == pos::ComputeStakeModifier(pindexPrev->stakeModifier, key);
 }
 
-namespace pos {
-
 /// Check PoS signatures (PoS block hashes are signed with coinstake out pubkey)
-    bool CheckHeaderSignature(const CBlockHeader& block) {
-        if (!block.IsProofOfStake()) {
+bool CheckHeaderSignature(const CBlockHeader& blockHeader) {
+    if (blockHeader.sig.empty()) {
+        if (blockHeader.height == 0) {
             return true;
         }
+        LogPrintf("CheckBlockSignature: Bad Block - PoS signature is empty\n");
+        return false;
+    }
 
-        if (block.proofOfStakeBody->sig.empty()) {
-            LogPrintf("CheckBlockSignature: Bad Block - PoS signature is empty\n");
-            return false;
-        }
+    CPubKey recoveredPubKey{};
+    if (!recoveredPubKey.RecoverCompact(blockHeader.GetHashToSign(), blockHeader.sig)) {
+        LogPrintf("CheckBlockSignature: Bad Block - malformed signature\n");
+        return false;
+    }
 
-        CPubKey recoveredPubKey{};
-        if (!recoveredPubKey.RecoverCompact(block.GetHashToSign(), block.proofOfStakeBody->sig)) {
-            LogPrintf("CheckBlockSignature: Bad Block - malformed signature\n");
-            return false;
-        }
+    return true;
+}
 
-        if (recoveredPubKey.GetID() != block.proofOfStakeBody->pubKeyHash) {
-            LogPrintf("CheckBlockSignature: Bad Block - wrong signature\n");
-            return false;
-        }
-        return true;
+bool CheckProofOfStake_headerOnly(const CBlockHeader& blockHeader, const Consensus::Params& params, CMasternodesView* mnView) {
+    // checking PoS kernel is faster, so check it first
+    if (!CheckKernelHash(blockHeader.stakeModifier, blockHeader.nBits, (int64_t) blockHeader.GetBlockTime(), params, mnView).hashOk) {
+        return false;
     }
 
-    bool CheckProofOfStake_headerOnly(const CBlockHeader& block, const Consensus::Params& params) {
-        if (!block.IsProofOfStake()) {
-            return error("CheckProofOfStake_headerOnly(): called on non-PoS %s", block.GetHash().ToString());
-        }
+    // TODO: (SS) check address masternode operator in mnView
 
-        const int64_t coinstakeTime = (int64_t) block.GetBlockTime();
-        const auto& body = *block.proofOfStakeBody; // checked to exist after IsProofOfStake
+    return CheckHeaderSignature(blockHeader);
+}
 
-        // checking PoS kernel is faster, so check it first
-        if (!CheckKernelHash(block.stakeModifier, block.nBits, coinstakeTime, body.coinstakeAmount,
-                             body.coinstakePrevout, params).hashOk) {
-            return false;
-        }
-        return CheckHeaderSignature(block);
+bool CheckProofOfStake(const CBlockHeader& blockHeader, const CBlockIndex* pindexPrev, const Consensus::Params& params, CMasternodesView* mnView) {
+    if (!pos::CheckStakeModifier(pindexPrev, blockHeader)) {
+        return false;
     }
 
-    bool CheckProofOfStake(const CBlockIndex* pindexPrev, const CBlock& block, CCoinsViewCache& view,
-                           const Consensus::Params& params) {
-        if (block.IsProofOfStake() != block.HasCoinstakeTx()) {
-            return false; // block claimed it's PoS, but doesn't have coinstakeTx
-        }
-        if (!block.IsCompleteProofOfStake()) {
-            return error("CheckProofOfStake(): called on a non-PoS block %s", block.GetHash().ToString());
-        }
+    return CheckProofOfStake_headerOnly(blockHeader, params, mnView);
+}
 
-        const auto& body = *block.proofOfStakeBody; // checked to exist after IsProofOfStake
+unsigned int CalculateNextWorkRequired(const CBlockIndex* pindexLast, int64_t nFirstBlockTime, const Consensus::Params::PoS& params)
+{
+    if (params.fNoRetargeting)
+        return pindexLast->nBits;
+
+    // Limit adjustment step
+    int64_t nActualTimespan = pindexLast->GetBlockTime() - nFirstBlockTime;
+    if (nActualTimespan < params.nTargetTimespan/4)
+        nActualTimespan = params.nTargetTimespan/4;
+    if (nActualTimespan > params.nTargetTimespan*4)
+        nActualTimespan = params.nTargetTimespan*4;
+
+    // Retarget
+    const arith_uint256 bnDiffLimit = UintToArith256(params.diffLimit);
+    arith_uint256 bnNew;
+    bnNew.SetCompact(pindexLast->nBits);
+    bnNew *= nActualTimespan;
+    bnNew /= params.nTargetTimespan;
+
+    if (bnNew > bnDiffLimit)
+        bnNew = bnDiffLimit;
+
+    return bnNew.GetCompact();
+}
 
-        if (body.coinstakePrevout != block.vtx[1]->vin[0].prevout)
-            return error("CheckProofOfStake(): block claimed PoS prevout doesn't match coinstakeTx (%s != %s)", body.coinstakePrevout.ToString(), block.vtx[1]->vin[0].prevout.ToString());
+unsigned int GetNextWorkRequired(const CBlockIndex* pindexLast, const CBlockHeader *pblock, const Consensus::Params::PoS& params)
+{
+    assert(pindexLast != nullptr);
+    unsigned int nProofOfWorkLimit = UintToArith256(params.diffLimit).GetCompact();
 
-        // check staker's pubKeyHash
+    // Only change once per difficulty adjustment interval
+    if ((pindexLast->nHeight+1) % params.DifficultyAdjustmentInterval() != 0)
+    {
+        if (params.fAllowMinDifficultyBlocks)
         {
-            std::vector<CTxDestination> addressRet;
-            txnouttype typeRet;
-            int nRet;
-            if (!ExtractDestinations(block.vtx[1]->vout[1].scriptPubKey, typeRet, addressRet, nRet))
-                return error("CheckProofOfStake(): coinstakeTx scriptPubKey must be P2PKH");
-            if (!(typeRet == txnouttype::TX_PUBKEYHASH && addressRet.size() == 1))
-                return error("CheckProofOfStake(): coinstakeTx scriptPubKey must be P2PKH");
-
-            CKeyID keyID(boost::get<PKHash>(addressRet[0]));
-            if (keyID != body.pubKeyHash)
-                return error("CheckProofOfStake(): coinstakeTx scriptPubKey and block pubKeyHash mismatch");
+            // Special difficulty rule for testnet:
+            // If the new block's timestamp is more than 2* 10 minutes
+            // then allow mining of a min-difficulty block.
+            if (pblock->GetBlockTime() > pindexLast->GetBlockTime() + params.nTargetSpacing*2)
+                return nProofOfWorkLimit;
+            else
+            {
+                // Return the last non-special-min-difficulty-rules-block
+                const CBlockIndex* pindex = pindexLast;
+                while (pindex->pprev && pindex->nHeight % params.DifficultyAdjustmentInterval() != 0 && pindex->nBits == nProofOfWorkLimit)
+                    pindex = pindex->pprev;
+                return pindex->nBits;
+            }
         }
+        return pindexLast->nBits;
+    }
 
-        // check staker's coin
-        {
-            const Coin& stakeCoin = view.AccessCoin(body.coinstakePrevout);
-            if (stakeCoin.IsSpent())
-                return error("CheckProofOfStake : Could not find previous transaction for PoS %s\n",
-                             body.coinstakePrevout.hash.ToString());
-            if ((pindexPrev->nHeight - stakeCoin.nHeight) < params.pos.coinstakeMaturity)
-                return error("CheckProofOfStake(): coinstakeTx input must have at least 100 confirmations");
-
-            if (body.coinstakeAmount != stakeCoin.out.nValue)
-                return error("CheckProofOfStake(): coinstakeTx amount and block coinstakeAmount mismatch");
-            // it's vital for security that we use the same scriptPubKey
-            if (block.vtx[1]->vout[1].scriptPubKey != stakeCoin.out.scriptPubKey)
-                return error("CheckProofOfStake(): coinstakeTx scriptPubKey and prev. scriptPubKey mismatch");
-        }
+    // Go back by what we want to be 14 days worth of blocks
+    int nHeightFirst = pindexLast->nHeight - (params.DifficultyAdjustmentInterval()-1);
+    assert(nHeightFirst >= 0);
+    const CBlockIndex* pindexFirst = pindexLast->GetAncestor(nHeightFirst);
+    assert(pindexFirst);
 
-        const int64_t coinstakeTime = (int64_t) block.GetBlockTime();
+    return pos::CalculateNextWorkRequired(pindexLast, pindexFirst->GetBlockTime(), params);
+}
 
-        // checking PoS kernel is faster, so check it first
-        if (!CheckKernelHash(block.stakeModifier, block.nBits, coinstakeTime, body.coinstakeAmount, body.coinstakePrevout,
-                             params).hashOk) {
-            return false;
-        }
-        return CheckHeaderSignature(block);
-    }
 }
diff --git a/src/pos.h b/src/pos.h
index 4fb3dbbeaa7..1a3da91eb49 100644
--- a/src/pos.h
+++ b/src/pos.h
@@ -2,6 +2,7 @@
 
 #include <consensus/params.h>
 #include <arith_uint256.h>
+#include <memory>
 
 class CBlock;
 
@@ -11,17 +12,22 @@ class CBlockHeader;
 
 class CCoinsViewCache;
 
+class CMasternodesView {}; // TODO: (SS) Change to real CMasternodesView class
+extern std::unique_ptr<CMasternodesView> pmasternodesview; // TODO: (SS) Change to real
+
 namespace pos {
 
 /// Check PoS signatures (PoS block hashes are signed with privkey of  first coinstake out pubkey)
     bool CheckHeaderSignature(const CBlockHeader& block);
 
 /// Check kernel hash target and coinstake signature
-    bool CheckProofOfStake_headerOnly(const CBlockHeader& block, const Consensus::Params& params);
+    bool CheckProofOfStake_headerOnly(const CBlockHeader& blockHeader, const Consensus::Params& params, CMasternodesView* mnView);
 
 /// Check kernel hash target and coinstake signature. Check that block coinstakeTx matches header
-    bool CheckProofOfStake(const CBlockIndex* pindexPrev, const CBlock& block, CCoinsViewCache& view,
-                           const Consensus::Params& params);
+    bool CheckProofOfStake(const CBlockHeader& blockHeader, const CBlockIndex* pindexPrev, const Consensus::Params& params, CMasternodesView* mnView);
+
+    unsigned int GetNextWorkRequired(const CBlockIndex* pindexLast, const CBlockHeader *pblock, const Consensus::Params::PoS& params);
 
+    unsigned int CalculateNextWorkRequired(const CBlockIndex* pindexLast, int64_t nFirstBlockTime, const Consensus::Params::PoS& params);
 }
 
diff --git a/src/pos_kernel.cpp b/src/pos_kernel.cpp
index 1072bcc512a..0f3d6cfecbe 100644
--- a/src/pos_kernel.cpp
+++ b/src/pos_kernel.cpp
@@ -1,45 +1,44 @@
 #include <pos_kernel.h>
+#include <amount.h>
 #include <wallet/wallet.h>
 #include <txdb.h>
 #include <validation.h>
 #include <arith_uint256.h>
+#include <key.h>
+#include <pos.h>
 
 namespace pos {
+    const uint64_t COINSTAKE_AMOUNT = 1000 * COIN;
 
-    uint256 CalcKernelHash(uint256 stakeModifier, int64_t coinstakeTime, const COutPoint& prevout,
-                           const Consensus::Params& params) {
+    uint256 CalcKernelHash(uint256 stakeModifier, int64_t coinstakeTime, uint256 masternodeID, const Consensus::Params& params) {
         // Calculate hash
         CDataStream ss(SER_GETHASH, 0);
-        ss << stakeModifier << coinstakeTime << prevout.hash << prevout.n;
+        ss << stakeModifier << coinstakeTime << COINSTAKE_AMOUNT << masternodeID;
         return Hash(ss.begin(), ss.end());
     }
 
     CheckKernelHashRes
-    CheckKernelHash(uint256 stakeModifier, uint32_t nBits, int64_t coinstakeTime, CAmount coinstakeAmount,
-                    const COutPoint& prevout, const Consensus::Params& params) {
-        if (prevout.IsNull() || coinstakeAmount <= 0) {
-            return {false, arith_uint256{}};
-        }
-
+    CheckKernelHash(uint256 stakeModifier, uint32_t nBits, int64_t coinstakeTime, const Consensus::Params& params, CMasternodesView* mnView) {
         // Base target
         arith_uint256 targetProofOfStake;
         targetProofOfStake.SetCompact(nBits);
 
+        uint256 masternodeID = uint256S("0"); // TODO: (SS) change to masternode activation tx hash
         const arith_uint256 hashProofOfStake = UintToArith256(
-                CalcKernelHash(stakeModifier, coinstakeTime, prevout, params));
+                CalcKernelHash(stakeModifier, coinstakeTime, masternodeID, params));
 
         // Now check if proof-of-stake hash meets target protocol
-        if ((hashProofOfStake / (uint64_t) coinstakeAmount) > targetProofOfStake) {
+        if ((hashProofOfStake / (uint64_t) COINSTAKE_AMOUNT) > targetProofOfStake) {
             return {false, hashProofOfStake};
         }
 
         return {true, hashProofOfStake};
     }
 
-    uint256 ComputeStakeModifier_PoS(uint256 prevStakeModifier, const COutPoint& prevout) {
+    uint256 ComputeStakeModifier(uint256 prevStakeModifier, const CKeyID& key) {
         // Calculate hash
         CDataStream ss(SER_GETHASH, 0);
-        ss << prevStakeModifier << prevout.hash << prevout.n;
+        ss << prevStakeModifier << key;
         return Hash(ss.begin(), ss.end());
     }
 }
diff --git a/src/pos_kernel.h b/src/pos_kernel.h
index 80bac531678..4412534019d 100644
--- a/src/pos_kernel.h
+++ b/src/pos_kernel.h
@@ -16,6 +16,10 @@ class CTransaction;
 
 class CCoinsViewCache;
 
+class CKeyID;
+
+class CMasternodesView;
+
 namespace pos {
 
     struct CheckKernelHashRes {
@@ -25,18 +29,13 @@ namespace pos {
 
 /// Calculate PoS kernel hash
     uint256
-    CalcKernelHash(uint256 stakeModifier, int64_t coinstakeTime, const COutPoint& prevout, const Consensus::Params& params);
+    CalcKernelHash(uint256 stakeModifier, int64_t coinstakeTime, uint256 masternodeID, const Consensus::Params& params);
 
 /// Check whether stake kernel meets hash target
 /// Sets hashProofOfStake, hashOk is true of the kernel meets hash target
     CheckKernelHashRes
-    CheckKernelHash(uint256 stakeModifier, uint32_t nBits, int64_t coinstakeTime, CAmount coinstakeAmount,
-                    const COutPoint& prevout, const Consensus::Params& params);
-
-/// Stake Modifier (hash modifier of proof-of-stake):
-/// The purpose of stake modifier is to prevent a txout (coin) owner from
-/// computing future proof-of-stake generated by this txout at the time
-/// of transaction confirmation. To meet kernel protocol, the txout
-/// must hash with a future stake modifier to generate the proof.
-    uint256 ComputeStakeModifier_PoS(uint256 prevStakeModifier, const COutPoint& prevout);
+    CheckKernelHash(uint256 stakeModifier, uint32_t nBits, int64_t coinstakeTime, const Consensus::Params& params, CMasternodesView* mnView);
+
+/// Stake Modifier (hash modifier of proof-of-stake)
+    uint256 ComputeStakeModifier(uint256 prevStakeModifier, const CKeyID& key);
 }
diff --git a/src/pow.cpp b/src/pow.cpp
deleted file mode 100644
index 1414d375649..00000000000
--- a/src/pow.cpp
+++ /dev/null
@@ -1,91 +0,0 @@
-// Copyright (c) 2009-2010 Satoshi Nakamoto
-// Copyright (c) 2009-2018 The Bitcoin Core developers
-// Distributed under the MIT software license, see the accompanying
-// file COPYING or http://www.opensource.org/licenses/mit-license.php.
-
-#include <pow.h>
-
-#include <arith_uint256.h>
-#include <chain.h>
-#include <primitives/block.h>
-#include <uint256.h>
-
-unsigned int GetNextWorkRequired(const CBlockIndex* pindexLast, const CBlockHeader *pblock, const Consensus::Params& params)
-{
-    assert(pindexLast != nullptr);
-    unsigned int nProofOfWorkLimit = UintToArith256(params.powLimit).GetCompact();
-
-    // Only change once per difficulty adjustment interval
-    if ((pindexLast->nHeight+1) % params.DifficultyAdjustmentInterval() != 0)
-    {
-        if (params.fPowAllowMinDifficultyBlocks)
-        {
-            // Special difficulty rule for testnet:
-            // If the new block's timestamp is more than 2* 10 minutes
-            // then allow mining of a min-difficulty block.
-            if (pblock->GetBlockTime() > pindexLast->GetBlockTime() + params.nPowTargetSpacing*2)
-                return nProofOfWorkLimit;
-            else
-            {
-                // Return the last non-special-min-difficulty-rules-block
-                const CBlockIndex* pindex = pindexLast;
-                while (pindex->pprev && pindex->nHeight % params.DifficultyAdjustmentInterval() != 0 && pindex->nBits == nProofOfWorkLimit)
-                    pindex = pindex->pprev;
-                return pindex->nBits;
-            }
-        }
-        return pindexLast->nBits;
-    }
-
-    // Go back by what we want to be 14 days worth of blocks
-    int nHeightFirst = pindexLast->nHeight - (params.DifficultyAdjustmentInterval()-1);
-    assert(nHeightFirst >= 0);
-    const CBlockIndex* pindexFirst = pindexLast->GetAncestor(nHeightFirst);
-    assert(pindexFirst);
-
-    return CalculateNextWorkRequired(pindexLast, pindexFirst->GetBlockTime(), params);
-}
-
-unsigned int CalculateNextWorkRequired(const CBlockIndex* pindexLast, int64_t nFirstBlockTime, const Consensus::Params& params)
-{
-    if (params.fPowNoRetargeting)
-        return pindexLast->nBits;
-
-    // Limit adjustment step
-    int64_t nActualTimespan = pindexLast->GetBlockTime() - nFirstBlockTime;
-    if (nActualTimespan < params.nPowTargetTimespan/4)
-        nActualTimespan = params.nPowTargetTimespan/4;
-    if (nActualTimespan > params.nPowTargetTimespan*4)
-        nActualTimespan = params.nPowTargetTimespan*4;
-
-    // Retarget
-    const arith_uint256 bnPowLimit = UintToArith256(params.powLimit);
-    arith_uint256 bnNew;
-    bnNew.SetCompact(pindexLast->nBits);
-    bnNew *= nActualTimespan;
-    bnNew /= params.nPowTargetTimespan;
-
-    if (bnNew > bnPowLimit)
-        bnNew = bnPowLimit;
-
-    return bnNew.GetCompact();
-}
-
-bool CheckProofOfWork(uint256 hash, unsigned int nBits, const Consensus::Params& params)
-{
-    bool fNegative;
-    bool fOverflow;
-    arith_uint256 bnTarget;
-
-    bnTarget.SetCompact(nBits, &fNegative, &fOverflow);
-
-    // Check range
-    if (fNegative || bnTarget == 0 || fOverflow || bnTarget > UintToArith256(params.powLimit))
-        return false;
-
-    // Check proof of work matches claimed amount
-    if (UintToArith256(hash) > bnTarget)
-        return false;
-
-    return true;
-}
diff --git a/src/pow.h b/src/pow.h
deleted file mode 100644
index 1d802cd01e4..00000000000
--- a/src/pow.h
+++ /dev/null
@@ -1,23 +0,0 @@
-// Copyright (c) 2009-2010 Satoshi Nakamoto
-// Copyright (c) 2009-2018 The Bitcoin Core developers
-// Distributed under the MIT software license, see the accompanying
-// file COPYING or http://www.opensource.org/licenses/mit-license.php.
-
-#ifndef BITCOIN_POW_H
-#define BITCOIN_POW_H
-
-#include <consensus/params.h>
-
-#include <stdint.h>
-
-class CBlockHeader;
-class CBlockIndex;
-class uint256;
-
-unsigned int GetNextWorkRequired(const CBlockIndex* pindexLast, const CBlockHeader *pblock, const Consensus::Params&);
-unsigned int CalculateNextWorkRequired(const CBlockIndex* pindexLast, int64_t nFirstBlockTime, const Consensus::Params&);
-
-/** Check whether a block hash satisfies the proof-of-work requirement specified by nBits */
-bool CheckProofOfWork(uint256 hash, unsigned int nBits, const Consensus::Params&);
-
-#endif // BITCOIN_POW_H
diff --git a/src/primitives/block.cpp b/src/primitives/block.cpp
index dcc292b555d..0a5f1d97124 100644
--- a/src/primitives/block.cpp
+++ b/src/primitives/block.cpp
@@ -9,6 +9,7 @@
 #include <tinyformat.h>
 #include <util/strencodings.h>
 #include <crypto/common.h>
+#include <streams.h>
 
 uint256 CBlockHeader::GetHash() const
 {
@@ -17,19 +18,21 @@ uint256 CBlockHeader::GetHash() const
 
 uint256 CBlockHeader::GetHashToSign() const
 {
-    return SerializeHash(*this, SER_GETSIGNHASH);
+    CDataStream ss(SER_GETHASH, 0);
+    ss << nVersion << hashPrevBlock << hashMerkleRoot << nTime << nBits << height << mintedBlocks << stakeModifier;
+    return Hash(ss.begin(), ss.end());
 }
 
 std::string CBlock::ToString() const
 {
     std::stringstream s;
-    s << strprintf("CBlock(hash=%s, ver=0x%08x, hashPrevBlock=%s, hashMerkleRoot=%s, nTime=%u, nBits=%08x, nNonce=%u, vtx=%u)\n",
+    s << strprintf("CBlock(hash=%s, ver=0x%08x, hashPrevBlock=%s, hashMerkleRoot=%s, nTime=%u, nBits=%08x, height=%u, mintedBlocks=%u, vtx=%u)\n",
         GetHash().ToString(),
         nVersion,
         hashPrevBlock.ToString(),
         hashMerkleRoot.ToString(),
-        nTime, nBits, nNonce,
-        proofOfStakeBody ? HexStr(proofOfStakeBody->sig.begin(), proofOfStakeBody->sig.end()) : "Empty",
+        nTime, nBits,
+        height, mintedBlocks,
         vtx.size());
     for (const auto& tx : vtx) {
         s << "  " << tx->ToString() << "\n";
diff --git a/src/primitives/block.h b/src/primitives/block.h
index aaba64d7a4b..77d728c7258 100644
--- a/src/primitives/block.h
+++ b/src/primitives/block.h
@@ -23,40 +23,17 @@
 class CBlockHeader
 {
 public:
-    struct PoS {
-        COutPoint coinstakePrevout;
-
-        CKeyID pubKeyHash; // only for sanity checks
-
-        CAmount coinstakeAmount; // only for sanity checks
-
-        // PoS: block signature - signed by staker's privkey
-        std::vector<unsigned char> sig;
-
-        ADD_SERIALIZE_METHODS;
-
-        template <typename Stream, typename Operation>
-        inline void SerializationOp(Stream& s, Operation ser_action) {
-            READWRITE(coinstakePrevout);
-            READWRITE(pubKeyHash);
-            READWRITE(coinstakeAmount);
-//            bool hashToSignAction = s.GetType() & SER_GETSIGNHASH;
-//            if (!hashToSignAction) {
-//                READWRITE(sig);
-//            }
-        }
-    };
-
     // header
     int32_t nVersion;
     uint256 hashPrevBlock;
     uint256 hashMerkleRoot;
     uint32_t nTime;
     uint32_t nBits;
-    uint32_t nNonce;
 
-    uint256 stakeModifier; // only for sanity checks
-    boost::optional<PoS> proofOfStakeBody;
+    uint64_t height;
+    uint64_t mintedBlocks;
+    uint256 stakeModifier;
+    std::vector<unsigned char> sig;
 
     CBlockHeader()
     {
@@ -72,13 +49,10 @@ class CBlockHeader
         READWRITE(hashMerkleRoot);
         READWRITE(nTime);
         READWRITE(nBits);
-        READWRITE(nNonce);
         READWRITE(stakeModifier);
-
-        //PoS serialization
-        PoS loc_proofOfStake = proofOfStakeBody ? *proofOfStakeBody : PoS{};
-        READWRITE(loc_proofOfStake);
-        proofOfStakeBody = loc_proofOfStake;
+        READWRITE(height);
+        READWRITE(mintedBlocks);
+        READWRITE(sig);
     }
 
     void SetNull()
@@ -88,9 +62,10 @@ class CBlockHeader
         hashMerkleRoot.SetNull();
         nTime = 0;
         nBits = 0;
-        nNonce = 0;
         stakeModifier.SetNull();
-        proofOfStakeBody = boost::optional<PoS>{};
+        height = 0;
+        mintedBlocks = 0;
+        sig = {};
     }
 
     bool IsNull() const
@@ -98,11 +73,6 @@ class CBlockHeader
         return (nBits == 0);
     }
 
-    bool IsProofOfStake() const
-    {
-        return (bool) proofOfStakeBody;
-    }
-
     uint256 GetHashToSign() const;
 
     uint256 GetHash() const;
@@ -111,6 +81,17 @@ class CBlockHeader
     {
         return (int64_t)nTime;
     }
+
+    bool ExtractMinterKey(CKeyID &key) const
+    {
+        CPubKey recoveredPubKey{};
+        if (!recoveredPubKey.RecoverCompact(GetHashToSign(), sig)) {
+            return false;
+        }
+
+        key = recoveredPubKey.GetID();
+        return true;
+    }
 };
 
 
@@ -149,16 +130,6 @@ class CBlock : public CBlockHeader
         fChecked = false;
     }
 
-    bool HasCoinstakeTx() const
-    {
-        return vtx.size() > 1 && vtx[1]->IsCoinStake();
-    }
-
-    bool IsCompleteProofOfStake() const
-    {
-        return IsProofOfStake() && HasCoinstakeTx();
-    }
-
     CBlockHeader GetBlockHeader() const
     {
         CBlockHeader block;
@@ -167,9 +138,11 @@ class CBlock : public CBlockHeader
         block.hashMerkleRoot = hashMerkleRoot;
         block.nTime          = nTime;
         block.nBits          = nBits;
-        block.nNonce         = nNonce;
         block.stakeModifier  = stakeModifier;
-        block.proofOfStakeBody = proofOfStakeBody;
+        block.height         = height;
+        block.mintedBlocks   = mintedBlocks;
+        block.sig            = sig;
+
         return block;
     }
 
diff --git a/src/primitives/transaction.h b/src/primitives/transaction.h
index 7eabb7b253a..3d2a530a03b 100644
--- a/src/primitives/transaction.h
+++ b/src/primitives/transaction.h
@@ -343,12 +343,6 @@ class CTransaction
         return (vin.size() == 1 && vin[0].prevout.IsNull());
     }
 
-    bool IsCoinStake() const
-    {
-        // PoS: the coin stake transaction is marked with the first output empty
-        return (vin.size() > 0 && (!vin[0].prevout.IsNull()) && vout.size() >= 2 && vout[0].IsEmpty());
-    }
-
     friend bool operator==(const CTransaction& a, const CTransaction& b)
     {
         return a.hash == b.hash;
@@ -417,10 +411,6 @@ struct CMutableTransaction
     bool IsCoinBase() const {
         return (vin.size() == 1 && vin[0].prevout.IsNull());
     }
-    bool IsCoinStake() const {
-        // PoS: the coin stake transaction is marked with the first output empty
-        return (vin.size() > 0 && (!vin[0].prevout.IsNull()) && vout.size() >= 2 && vout[0].IsEmpty());
-    }
 };
 
 typedef std::shared_ptr<const CTransaction> CTransactionRef;
diff --git a/src/qt/bitcoingui.cpp b/src/qt/bitcoingui.cpp
index 323797a4b68..230b2fc0a25 100644
--- a/src/qt/bitcoingui.cpp
+++ b/src/qt/bitcoingui.cpp
@@ -905,7 +905,7 @@ void BitcoinGUI::updateHeadersSyncProgressLabel()
 {
     int64_t headersTipTime = clientModel->getHeaderTipTime();
     int headersTipHeight = clientModel->getHeaderTipHeight();
-    int estHeadersLeft = (GetTime() - headersTipTime) / Params().GetConsensus().nPowTargetSpacing;
+    int estHeadersLeft = (GetTime() - headersTipTime) / Params().GetConsensus().pos.nTargetSpacing;
     if (estHeadersLeft > HEADER_HEIGHT_DELTA_SYNC)
         progressBarLabel->setText(tr("Syncing Headers (%1%)...").arg(QString::number(100.0 / (headersTipHeight+estHeadersLeft)*headersTipHeight, 'f', 1)));
 }
diff --git a/src/qt/modaloverlay.cpp b/src/qt/modaloverlay.cpp
index 8ecc33da849..6461b0ceb87 100644
--- a/src/qt/modaloverlay.cpp
+++ b/src/qt/modaloverlay.cpp
@@ -128,9 +128,9 @@ void ModalOverlay::tipUpdate(int count, const QDateTime& blockDate, double nVeri
         // not syncing
         return;
 
-    // estimate the number of headers left based on nPowTargetSpacing
+    // estimate the number of headers left based on nTargetSpacing
     // and check if the gui is not aware of the best header (happens rarely)
-    int estimateNumHeadersLeft = bestHeaderDate.secsTo(currentDate) / Params().GetConsensus().nPowTargetSpacing;
+    int estimateNumHeadersLeft = bestHeaderDate.secsTo(currentDate) / Params().GetConsensus().pos.nTargetSpacing;
     bool hasBestHeader = bestHeaderHeight >= count;
 
     // show remaining number of blocks
@@ -143,7 +143,7 @@ void ModalOverlay::tipUpdate(int count, const QDateTime& blockDate, double nVeri
 }
 
 void ModalOverlay::UpdateHeaderSyncLabel() {
-    int est_headers_left = bestHeaderDate.secsTo(QDateTime::currentDateTime()) / Params().GetConsensus().nPowTargetSpacing;
+    int est_headers_left = bestHeaderDate.secsTo(QDateTime::currentDateTime()) / Params().GetConsensus().pos.nTargetSpacing;
     ui->numberOfBlocksLeft->setText(tr("Unknown. Syncing Headers (%1, %2%)...").arg(bestHeaderHeight).arg(QString::number(100.0 / (bestHeaderHeight + est_headers_left) * bestHeaderHeight, 'f', 1)));
 }
 
diff --git a/src/qt/sendcoinsdialog.cpp b/src/qt/sendcoinsdialog.cpp
index f23c47736fb..0e968c93a0f 100644
--- a/src/qt/sendcoinsdialog.cpp
+++ b/src/qt/sendcoinsdialog.cpp
@@ -165,7 +165,7 @@ void SendCoinsDialog::setModel(WalletModel *_model)
 
         // fee section
         for (const int n : confTargets) {
-            ui->confTargetSelector->addItem(tr("%1 (%2 blocks)").arg(GUIUtil::formatNiceTimeOffset(n*Params().GetConsensus().nPowTargetSpacing)).arg(n));
+            ui->confTargetSelector->addItem(tr("%1 (%2 blocks)").arg(GUIUtil::formatNiceTimeOffset(n*Params().GetConsensus().pos.nTargetSpacing)).arg(n));
         }
         connect(ui->confTargetSelector, static_cast<void (QComboBox::*)(int)>(&QComboBox::currentIndexChanged), this, &SendCoinsDialog::updateSmartFeeLabel);
         connect(ui->confTargetSelector, static_cast<void (QComboBox::*)(int)>(&QComboBox::currentIndexChanged), this, &SendCoinsDialog::coinControlUpdateLabels);
diff --git a/src/rpc/blockchain.cpp b/src/rpc/blockchain.cpp
index 5419e33396e..06e284e248b 100644
--- a/src/rpc/blockchain.cpp
+++ b/src/rpc/blockchain.cpp
@@ -106,7 +106,6 @@ UniValue blockheaderToJSON(const CBlockIndex* tip, const CBlockIndex* blockindex
     result.pushKV("merkleroot", blockindex->hashMerkleRoot.GetHex());
     result.pushKV("time", (int64_t)blockindex->nTime);
     result.pushKV("mediantime", (int64_t)blockindex->GetMedianTimePast());
-    result.pushKV("nonce", (uint64_t)blockindex->nNonce);
     result.pushKV("bits", strprintf("%08x", blockindex->nBits));
     result.pushKV("difficulty", GetDifficulty(blockindex));
     result.pushKV("chainwork", blockindex->nChainWork.GetHex());
@@ -151,7 +150,6 @@ UniValue blockToJSON(const CBlock& block, const CBlockIndex* tip, const CBlockIn
     result.pushKV("tx", txs);
     result.pushKV("time", block.GetBlockTime());
     result.pushKV("mediantime", (int64_t)blockindex->GetMedianTimePast());
-    result.pushKV("nonce", (uint64_t)block.nNonce);
     result.pushKV("bits", strprintf("%08x", block.nBits));
     result.pushKV("difficulty", GetDifficulty(blockindex));
     result.pushKV("chainwork", blockindex->nChainWork.GetHex());
@@ -1583,7 +1581,7 @@ static UniValue getchaintxstats(const JSONRPCRequest& request)
             }.Check(request);
 
     const CBlockIndex* pindex;
-    int blockcount = 30 * 24 * 60 * 60 / Params().GetConsensus().nPowTargetSpacing; // By default: 1 month
+    int blockcount = 30 * 24 * 60 * 60 / Params().GetConsensus().pos.nTargetSpacing; // By default: 1 month
 
     if (request.params[1].isNull()) {
         LOCK(cs_main);
diff --git a/src/rpc/mining.cpp b/src/rpc/mining.cpp
index 62a4f16ef49..094853c42bd 100644
--- a/src/rpc/mining.cpp
+++ b/src/rpc/mining.cpp
@@ -14,7 +14,7 @@
 #include <miner.h>
 #include <net.h>
 #include <policy/fees.h>
-#include <pow.h>
+#include <pos.h>
 #include <rpc/blockchain.h>
 #include <rpc/server.h>
 #include <rpc/util.h>
@@ -50,7 +50,7 @@ static UniValue GetNetworkHashPS(int lookup, int height) {
 
     // If lookup is -1, then use blocks since last difficulty change.
     if (lookup <= 0)
-        lookup = pb->nHeight % Params().GetConsensus().DifficultyAdjustmentInterval() + 1;
+        lookup = pb->nHeight % Params().GetConsensus().pos.DifficultyAdjustmentInterval() + 1;
 
     // If lookup is larger than chain, then set it to chain length.
     if (lookup > pb->nHeight)
@@ -121,16 +121,13 @@ static UniValue generateBlocks(const CScript& coinbase_script, int nGenerate, ui
             LOCK(cs_main);
             IncrementExtraNonce(pblock, ::ChainActive().Tip(), nExtraNonce);
         }
-        while (nMaxTries > 0 && pblock->nNonce < std::numeric_limits<uint32_t>::max() && !CheckProofOfWork(pblock->GetHash(), pblock->nBits, Params().GetConsensus()) && !ShutdownRequested()) {
-            ++pblock->nNonce;
-            --nMaxTries;
-        }
+//        while (nMaxTries > 0 && !CheckProofOfWork(pblock->GetHash(), pblock->nBits, Params().GetConsensus()) && !ShutdownRequested()) {
+//            ++pblock->nNonce;
+//            --nMaxTries;
+//        }
         if (nMaxTries == 0 || ShutdownRequested()) {
             break;
         }
-        if (pblock->nNonce == std::numeric_limits<uint32_t>::max()) {
-            continue;
-        }
         std::shared_ptr<const CBlock> shared_pblock = std::make_shared<const CBlock>(*pblock);
         if (!ProcessNewBlock(Params(), shared_pblock, true, nullptr))
             throw JSONRPCError(RPC_INTERNAL_ERROR, "ProcessNewBlock, block not accepted");
@@ -517,7 +514,6 @@ static UniValue getblocktemplate(const JSONRPCRequest& request)
 
     // Update nTime
     UpdateTime(pblock, consensusParams, pindexPrev);
-    pblock->nNonce = 0;
 
     // NOTE: If at some point we support pre-segwit miners post-segwit-activation, this needs to take segwit support into consideration
     const bool fPreSegWit = (pindexPrev->nHeight + 1 < consensusParams.SegwitHeight);
diff --git a/src/serialize.h b/src/serialize.h
index a74f2ffd8a5..a38d76fc18b 100644
--- a/src/serialize.h
+++ b/src/serialize.h
@@ -175,7 +175,6 @@ enum
     SER_NETWORK         = (1 << 0),
     SER_DISK            = (1 << 1),
     SER_GETHASH         = (1 << 2),
-    SER_GETSIGNHASH     = (1 << 3),
 };
 
 //! Convert the reference base type to X, without changing constness or reference type.
diff --git a/src/test/blockencodings_tests.cpp b/src/test/blockencodings_tests.cpp
index 5ce8e6feb04..fd5ff09a7ab 100644
--- a/src/test/blockencodings_tests.cpp
+++ b/src/test/blockencodings_tests.cpp
@@ -5,7 +5,7 @@
 #include <blockencodings.h>
 #include <consensus/merkle.h>
 #include <chainparams.h>
-#include <pow.h>
+#include <pos.h>
 #include <streams.h>
 
 #include <test/setup_common.h>
@@ -48,7 +48,7 @@ static CBlock BuildBlockTestCase() {
     bool mutated;
     block.hashMerkleRoot = BlockMerkleRoot(block, &mutated);
     assert(!mutated);
-    while (!CheckProofOfWork(block.GetHash(), block.nBits, Params().GetConsensus())) ++block.nNonce;
+  //  while (!CheckProofOfWork(block.GetHash(), block.nBits, Params().GetConsensus())) ++block.nNonce;
     return block;
 }
 
@@ -296,7 +296,7 @@ BOOST_AUTO_TEST_CASE(EmptyBlockRoundTripTest)
     bool mutated;
     block.hashMerkleRoot = BlockMerkleRoot(block, &mutated);
     assert(!mutated);
-    while (!CheckProofOfWork(block.GetHash(), block.nBits, Params().GetConsensus())) ++block.nNonce;
+   // while (!CheckProofOfWork(block.GetHash(), block.nBits, Params().GetConsensus())) ++block.nNonce;
 
     // Test simple header round-trip with only coinbase
     {
diff --git a/src/test/blockfilter_index_tests.cpp b/src/test/blockfilter_index_tests.cpp
index cf87aa9303b..a64d56d1497 100644
--- a/src/test/blockfilter_index_tests.cpp
+++ b/src/test/blockfilter_index_tests.cpp
@@ -7,7 +7,7 @@
 #include <consensus/validation.h>
 #include <index/blockfilterindex.h>
 #include <miner.h>
-#include <pow.h>
+#include <pos.h>
 #include <test/setup_common.h>
 #include <script/standard.h>
 #include <util/time.h>
@@ -87,7 +87,7 @@ static CBlock CreateBlock(const CBlockIndex* prev,
     unsigned int extraNonce = 0;
     IncrementExtraNonce(&block, prev, extraNonce);
 
-    while (!CheckProofOfWork(block.GetHash(), block.nBits, chainparams.GetConsensus())) ++block.nNonce;
+  //  while (!CheckProofOfWork(block.GetHash(), block.nBits, chainparams.GetConsensus())) ++block.nNonce;
 
     return block;
 }
diff --git a/src/test/denialofservice_tests.cpp b/src/test/denialofservice_tests.cpp
index a50d6854f89..96af4973ccb 100644
--- a/src/test/denialofservice_tests.cpp
+++ b/src/test/denialofservice_tests.cpp
@@ -172,7 +172,7 @@ BOOST_AUTO_TEST_CASE(stale_tip_peer_management)
         BOOST_CHECK(node->fDisconnect == false);
     }
 
-    SetMockTime(GetTime() + 3*consensusParams.nPowTargetSpacing + 1);
+    SetMockTime(GetTime() + 3*consensusParams.pos.nTargetSpacing + 1);
 
     // Now tip should definitely be stale, and we should look for an extra
     // outbound peer
diff --git a/src/test/miner_tests.cpp b/src/test/miner_tests.cpp
index 8aef234be0d..6b957572858 100644
--- a/src/test/miner_tests.cpp
+++ b/src/test/miner_tests.cpp
@@ -244,7 +244,7 @@ BOOST_AUTO_TEST_CASE(CreateNewBlock_validity)
             if (txFirst.size() < 4)
                 txFirst.push_back(pblock->vtx[0]);
             pblock->hashMerkleRoot = BlockMerkleRoot(*pblock);
-            pblock->nNonce = blockinfo[i].nonce;
+            // pblock->nNonce = blockinfo[i].nonce;
         }
         std::shared_ptr<const CBlock> shared_pblock = std::make_shared<const CBlock>(*pblock);
         BOOST_CHECK(ProcessNewBlock(chainparams, shared_pblock, true, nullptr));
diff --git a/src/test/pow_tests.cpp b/src/test/pow_tests.cpp
index 1123d4202c8..ba255175aad 100644
--- a/src/test/pow_tests.cpp
+++ b/src/test/pow_tests.cpp
@@ -4,7 +4,7 @@
 
 #include <chain.h>
 #include <chainparams.h>
-#include <pow.h>
+#include <pos.h>
 #include <util/system.h>
 #include <test/setup_common.h>
 
@@ -21,7 +21,7 @@ BOOST_AUTO_TEST_CASE(get_next_work)
     pindexLast.nHeight = 32255;
     pindexLast.nTime = 1262152739;  // Block #32255
     pindexLast.nBits = 0x1d00ffff;
-    BOOST_CHECK_EQUAL(CalculateNextWorkRequired(&pindexLast, nLastRetargetTime, chainParams->GetConsensus()), 0x1d00d86aU);
+    BOOST_CHECK_EQUAL(pos::CalculateNextWorkRequired(&pindexLast, nLastRetargetTime, chainParams->GetConsensus().pos), 0x1d00d86aU);
 }
 
 /* Test the constraint on the upper bound for next work */
@@ -33,7 +33,7 @@ BOOST_AUTO_TEST_CASE(get_next_work_pow_limit)
     pindexLast.nHeight = 2015;
     pindexLast.nTime = 1233061996;  // Block #2015
     pindexLast.nBits = 0x1d00ffff;
-    BOOST_CHECK_EQUAL(CalculateNextWorkRequired(&pindexLast, nLastRetargetTime, chainParams->GetConsensus()), 0x1d00ffffU);
+    BOOST_CHECK_EQUAL(pos::CalculateNextWorkRequired(&pindexLast, nLastRetargetTime, chainParams->GetConsensus().pos), 0x1d00ffffU);
 }
 
 /* Test the constraint on the lower bound for actual time taken */
@@ -45,7 +45,7 @@ BOOST_AUTO_TEST_CASE(get_next_work_lower_limit_actual)
     pindexLast.nHeight = 68543;
     pindexLast.nTime = 1279297671;  // Block #68543
     pindexLast.nBits = 0x1c05a3f4;
-    BOOST_CHECK_EQUAL(CalculateNextWorkRequired(&pindexLast, nLastRetargetTime, chainParams->GetConsensus()), 0x1c0168fdU);
+    BOOST_CHECK_EQUAL(pos::CalculateNextWorkRequired(&pindexLast, nLastRetargetTime, chainParams->GetConsensus().pos), 0x1c0168fdU);
 }
 
 /* Test the constraint on the upper bound for actual time taken */
@@ -57,7 +57,7 @@ BOOST_AUTO_TEST_CASE(get_next_work_upper_limit_actual)
     pindexLast.nHeight = 46367;
     pindexLast.nTime = 1269211443;  // Block #46367
     pindexLast.nBits = 0x1c387f6f;
-    BOOST_CHECK_EQUAL(CalculateNextWorkRequired(&pindexLast, nLastRetargetTime, chainParams->GetConsensus()), 0x1d00e1fdU);
+    BOOST_CHECK_EQUAL(pos::CalculateNextWorkRequired(&pindexLast, nLastRetargetTime, chainParams->GetConsensus().pos), 0x1d00e1fdU);
 }
 
 BOOST_AUTO_TEST_CASE(GetBlockProofEquivalentTime_test)
@@ -67,7 +67,7 @@ BOOST_AUTO_TEST_CASE(GetBlockProofEquivalentTime_test)
     for (int i = 0; i < 10000; i++) {
         blocks[i].pprev = i ? &blocks[i - 1] : nullptr;
         blocks[i].nHeight = i;
-        blocks[i].nTime = 1269211443 + i * chainParams->GetConsensus().nPowTargetSpacing;
+        blocks[i].nTime = 1269211443 + i * chainParams->GetConsensus().pos.nTargetSpacing;
         blocks[i].nBits = 0x207fffff; /* target 0x7fffff000... */
         blocks[i].nChainWork = i ? blocks[i - 1].nChainWork + GetBlockProof(blocks[i - 1]) : arith_uint256(0);
     }
diff --git a/src/test/setup_common.cpp b/src/test/setup_common.cpp
index bbdf1ef830e..87988d6bbef 100644
--- a/src/test/setup_common.cpp
+++ b/src/test/setup_common.cpp
@@ -14,7 +14,7 @@
 #include <miner.h>
 #include <net.h>
 #include <noui.h>
-#include <pow.h>
+#include <pos.h>
 #include <rpc/register.h>
 #include <rpc/server.h>
 #include <script/sigcache.h>
@@ -161,7 +161,7 @@ TestChain100Setup::CreateAndProcessBlock(const std::vector<CMutableTransaction>&
         IncrementExtraNonce(&block, ::ChainActive().Tip(), extraNonce);
     }
 
-    while (!CheckProofOfWork(block.GetHash(), block.nBits, chainparams.GetConsensus())) ++block.nNonce;
+ //   while (!CheckProofOfWork(block.GetHash(), block.nBits, chainparams.GetConsensus())) ++block.nNonce;
 
     std::shared_ptr<const CBlock> shared_pblock = std::make_shared<const CBlock>(block);
     ProcessNewBlock(chainparams, shared_pblock, true, nullptr);
diff --git a/src/test/util.cpp b/src/test/util.cpp
index b7bb6deeaae..081b5ff8619 100644
--- a/src/test/util.cpp
+++ b/src/test/util.cpp
@@ -9,7 +9,7 @@
 #include <key_io.h>
 #include <miner.h>
 #include <outputtype.h>
-#include <pow.h>
+#include <pos.h>
 #include <script/standard.h>
 #include <validation.h>
 #include <validationinterface.h>
@@ -56,10 +56,10 @@ CTxIn MineBlock(const CScript& coinbase_scriptPubKey)
 {
     auto block = PrepareBlock(coinbase_scriptPubKey);
 
-    while (!CheckProofOfWork(block->GetHash(), block->nBits, Params().GetConsensus())) {
-        ++block->nNonce;
-        assert(block->nNonce);
-    }
+//    while (!CheckProofOfWork(block->GetHash(), block->nBits, Params().GetConsensus())) { // TODO: (SS) I broke this
+//        ++block->nNonce;
+//        assert(block->nNonce);
+//    }
 
     bool processed{ProcessNewBlock(Params(), block, true, nullptr)};
     assert(processed);
diff --git a/src/test/validation_block_tests.cpp b/src/test/validation_block_tests.cpp
index b3368d44b61..cd9e91f2366 100644
--- a/src/test/validation_block_tests.cpp
+++ b/src/test/validation_block_tests.cpp
@@ -8,7 +8,7 @@
 #include <consensus/merkle.h>
 #include <consensus/validation.h>
 #include <miner.h>
-#include <pow.h>
+#include <pos.h>
 #include <random.h>
 #include <script/standard.h>
 #include <test/setup_common.h>
@@ -93,9 +93,9 @@ std::shared_ptr<CBlock> FinalizeBlock(std::shared_ptr<CBlock> pblock)
 
     pblock->hashMerkleRoot = BlockMerkleRoot(*pblock);
 
-    while (!CheckProofOfWork(pblock->GetHash(), pblock->nBits, Params().GetConsensus())) {
-        ++(pblock->nNonce);
-    }
+//    while (!CheckProofOfWork(pblock->GetHash(), pblock->nBits, Params().GetConsensus())) {
+//        ++(pblock->nNonce);
+//    }
 
     return pblock;
 }
diff --git a/src/txdb.cpp b/src/txdb.cpp
index be4adfa52de..c2b0d5a5aa7 100644
--- a/src/txdb.cpp
+++ b/src/txdb.cpp
@@ -5,7 +5,7 @@
 
 #include <txdb.h>
 
-#include <pow.h>
+#include <pos.h>
 #include <random.h>
 #include <shutdown.h>
 #include <ui_interface.h>
@@ -270,16 +270,23 @@ bool CBlockTreeDB::LoadBlockIndexGuts(const Consensus::Params& consensusParams,
                 pindexNew->hashMerkleRoot = diskindex.hashMerkleRoot;
                 pindexNew->nTime          = diskindex.nTime;
                 pindexNew->nBits          = diskindex.nBits;
-                pindexNew->nNonce         = diskindex.nNonce;
                 pindexNew->nStatus        = diskindex.nStatus;
                 pindexNew->nTx            = diskindex.nTx;
 
                 //PoS
                 pindexNew->stakeModifier = diskindex.stakeModifier;
-                pindexNew->proofOfStakeBody = diskindex.proofOfStakeBody;
+                pindexNew->height = diskindex.height;
+                pindexNew->mintedBlocks = diskindex.mintedBlocks;
+                pindexNew->sig = diskindex.sig;
 
-                if (!CheckProofOfWork(pindexNew->GetBlockHash(), pindexNew->nBits, consensusParams))
-                    return error("%s: CheckProofOfWork failed: %s", __func__, pindexNew->ToString());
+                CPubKey recoveredPubKey{};
+                if (!recoveredPubKey.RecoverCompact(diskindex.GetHashToSign(), diskindex.sig)) {
+                    return error("%s: The block index #%d (%s) wasn't saved on disk correctly. Index content: %s", __func__, pindexNew->nHeight, pindexNew->GetBlockHash().ToString(), pindexNew->ToString());
+                }
+                pindexNew->minter = recoveredPubKey.GetID();
+
+                if (pindexNew->nHeight > 0 && pindexNew->stakeModifier == uint256{})
+                    return error("%s: The block index #%d (%s) wasn't saved on disk correctly. Index content: %s", __func__, pindexNew->nHeight, pindexNew->GetBlockHash().ToString(), pindexNew->ToString());
 
                 pcursor->Next();
             } else {
diff --git a/src/validation.cpp b/src/validation.cpp
index 95c8aca8bb0..bb8191f3511 100644
--- a/src/validation.cpp
+++ b/src/validation.cpp
@@ -21,7 +21,7 @@
 #include <policy/fees.h>
 #include <policy/policy.h>
 #include <policy/settings.h>
-#include <pow.h>
+#include <pos.h>
 #include <primitives/block.h>
 #include <primitives/transaction.h>
 #include <random.h>
@@ -965,7 +965,7 @@ bool ReadBlockFromDisk(CBlock& block, const FlatFilePos& pos, const Consensus::P
     }
 
     // Check the header
-    if (!CheckProofOfWork(block.GetHash(), block.nBits, consensusParams))
+    if (!pos::CheckProofOfStake_headerOnly(block, consensusParams, pmasternodesview.get()))
         return error("ReadBlockFromDisk: Errors in block header at %s", pos.ToString());
 
     return true;
@@ -3017,10 +3017,8 @@ static bool FindUndoPos(CValidationState &state, int nFile, FlatFilePos &pos, un
 
 static bool CheckBlockHeader(const CBlockHeader& block, CValidationState& state, const Consensus::Params& consensusParams, bool fCheckPOW = true)
 {
-    // Check proof of work matches claimed amount
-    if (fCheckPOW && !CheckProofOfWork(block.GetHash(), block.nBits, consensusParams))
-        return state.Invalid(ValidationInvalidReason::BLOCK_INVALID_HEADER, false, REJECT_INVALID, "high-hash", "proof of work failed");
-
+    if (fCheckPOW && !pos::CheckProofOfStake_headerOnly(block, consensusParams, pmasternodesview.get()))
+        return state.Invalid(ValidationInvalidReason::BLOCK_INVALID_HEADER, false, REJECT_INVALID, "high-hash", "proof of stake failed");
     return true;
 }
 
@@ -3181,7 +3179,7 @@ static bool ContextualCheckBlockHeader(const CBlockHeader& block, CValidationSta
 
     // Check proof of work
     const Consensus::Params& consensusParams = params.GetConsensus();
-    if (block.nBits != GetNextWorkRequired(pindexPrev, &block, consensusParams))
+    if (block.nBits != pos::GetNextWorkRequired(pindexPrev, &block, consensusParams.pos))
         return state.Invalid(ValidationInvalidReason::BLOCK_INVALID_HEADER, false, REJECT_INVALID, "bad-diffbits", "incorrect proof of work");
 
     // Check against checkpoints
@@ -3319,7 +3317,7 @@ bool BlockManager::AcceptBlockHeader(const CBlockHeader& block, CValidationState
             return true;
         }
 
-        if (!CheckBlockHeader(block, state, chainparams.GetConsensus()))
+        if (!pos::CheckProofOfStake_headerOnly(block, chainparams.GetConsensus(), pmasternodesview.get()))
             return error("%s: Consensus::CheckBlockHeader: %s, %s", __func__, hash.ToString(), FormatStateMessage(state));
 
         // Get prev block index
@@ -3404,7 +3402,7 @@ bool ProcessNewBlockHeaders(const std::vector<CBlockHeader>& headers, CValidatio
     {
         LOCK(cs_main);
         if (::ChainstateActive().IsInitialBlockDownload() && ppindex && *ppindex) {
-            LogPrintf("Synchronizing blockheaders, height: %d (~%.2f%%)\n", (*ppindex)->nHeight, 100.0/((*ppindex)->nHeight+(GetAdjustedTime() - (*ppindex)->GetBlockTime()) / Params().GetConsensus().nPowTargetSpacing) * (*ppindex)->nHeight);
+            LogPrintf("Synchronizing blockheaders, height: %d (~%.2f%%)\n", (*ppindex)->nHeight, 100.0/((*ppindex)->nHeight+(GetAdjustedTime() - (*ppindex)->GetBlockTime()) / Params().GetConsensus().pos.nTargetSpacing) * (*ppindex)->nHeight);
         }
     }
     return true;
diff --git a/src/wallet/wallet.cpp b/src/wallet/wallet.cpp
index 4047c041723..5f6260aa424 100644
--- a/src/wallet/wallet.cpp
+++ b/src/wallet/wallet.cpp
@@ -4645,7 +4645,7 @@ int CWalletTx::GetDepthInMainChain(interfaces::Chain::Lock& locked_chain) const
 
 int CWalletTx::GetBlocksToMaturity(interfaces::Chain::Lock& locked_chain) const
 {
-    if (!IsCoinStake())
+    if (!IsCoinBase())
         return 0;
     int chain_depth = GetDepthInMainChain(locked_chain);
     assert(chain_depth >= 0); // coinstake tx should not be conflicted
diff --git a/src/wallet/wallet.h b/src/wallet/wallet.h
index f33ea50ca3a..984be3e3013 100644
--- a/src/wallet/wallet.h
+++ b/src/wallet/wallet.h
@@ -613,7 +613,6 @@ class CWalletTx
 
     const uint256& GetHash() const { return tx->GetHash(); }
     bool IsCoinBase() const { return tx->IsCoinBase(); }
-    bool IsCoinStake() const { return tx->IsCoinStake(); }
     bool IsImmatureCoinBase(interfaces::Chain::Lock& locked_chain) const;
 };