diff --git a/pkg/node/node.go b/pkg/node/node.go
index 486e76e324f..f4388668be5 100644
--- a/pkg/node/node.go
+++ b/pkg/node/node.go
@@ -1004,18 +1004,44 @@ func NewBee(
 
 	stakingContract := staking.New(overlayEthAddress, stakingContractAddress, abiutil.MustParseABI(chainCfg.StakingABI), bzzTokenAddress, transactionService, common.BytesToHash(nonce), o.TrxDebugMode, uint8(o.ReserveCapacityDoubling))
 
-	if chainEnabled && changedOverlay {
-		stake, err := stakingContract.GetPotentialStake(ctx)
+	if chainEnabled {
+
+		if changedOverlay {
+			stake, err := stakingContract.GetPotentialStake(ctx)
+			if err != nil {
+				return nil, err
+			}
+			if stake.Cmp(big.NewInt(0)) > 0 {
+				logger.Debug("changing overlay address in staking contract")
+				tx, err := stakingContract.ChangeStakeOverlay(ctx, common.BytesToHash(nonce))
+				if err != nil {
+					return nil, fmt.Errorf("cannot change staking overlay address: %v", err.Error())
+				}
+				logger.Info("overlay address changed in staking contract", "transaction", tx)
+			}
+		}
+
+		// make sure that the staking contract has the up to date height
+		tx, updated, err := stakingContract.UpdateHeight(ctx)
 		if err != nil {
-			return nil, errors.New("getting stake balance")
+			return nil, err
+		}
+		if updated {
+			logger.Info("updated new reserve capacity doubling height in the staking contract", "transaction", tx, "new_height", o.ReserveCapacityDoubling)
 		}
-		if stake.Cmp(big.NewInt(0)) > 0 {
-			logger.Debug("changing overlay address in staking contract")
-			tx, err := stakingContract.ChangeStakeOverlay(ctx, common.BytesToHash(nonce))
+
+		if o.ReserveCapacityDoubling > 0 {
+			stake, err := stakingContract.GetPotentialStake(ctx)
 			if err != nil {
-				return nil, fmt.Errorf("cannot change staking overlay address: %v", err.Error())
+				return nil, err
+			}
+			if stake.Cmp(big.NewInt(0)) > 0 {
+				// Check if the staked amount is sufficient to cover the additional neighborhoods.
+				// The staked amount must be at least 2^h * MinimumStake.
+				if stake.Cmp(big.NewInt(0).Mul(big.NewInt(1<<o.ReserveCapacityDoubling), staking.MinimumStakeAmount)) < 0 {
+					logger.Warning("staked amount does not sufficiently cover the additional reserve capacity. Stake should be at least 2^h * 10 BZZ, where h is the number extra doublings.")
+				}
 			}
-			logger.Info("overlay address changed in staking contract", "transaction", tx)
 		}
 	}
 
diff --git a/pkg/storageincentives/staking/contract.go b/pkg/storageincentives/staking/contract.go
index 365153f5917..cf95baec874 100644
--- a/pkg/storageincentives/staking/contract.go
+++ b/pkg/storageincentives/staking/contract.go
@@ -44,6 +44,7 @@ type Contract interface {
 	GetWithdrawableStake(ctx context.Context) (*big.Int, error)
 	WithdrawStake(ctx context.Context) (common.Hash, error)
 	MigrateStake(ctx context.Context) (common.Hash, error)
+	UpdateHeight(ctx context.Context) (common.Hash, bool, error)
 	RedistributionStatuser
 }
 
@@ -116,7 +117,7 @@ func (c *contract) DepositStake(ctx context.Context, stakedAmount *big.Int) (com
 		return common.Hash{}, err
 	}
 
-	receipt, err := c.sendDepositStakeTransaction(ctx, stakedAmount, c.overlayNonce)
+	receipt, err := c.sendManageStakeTransaction(ctx, stakedAmount)
 	if err != nil {
 		return common.Hash{}, err
 	}
@@ -127,7 +128,7 @@ func (c *contract) DepositStake(ctx context.Context, stakedAmount *big.Int) (com
 // ChangeStakeOverlay only changes the overlay address used in the redistribution game.
 func (c *contract) ChangeStakeOverlay(ctx context.Context, nonce common.Hash) (common.Hash, error) {
 	c.overlayNonce = nonce
-	receipt, err := c.sendDepositStakeTransaction(ctx, new(big.Int), c.overlayNonce)
+	receipt, err := c.sendManageStakeTransaction(ctx, new(big.Int))
 	if err != nil {
 		return common.Hash{}, err
 	}
@@ -135,6 +136,26 @@ func (c *contract) ChangeStakeOverlay(ctx context.Context, nonce common.Hash) (c
 	return receipt.TxHash, nil
 }
 
+// UpdateHeight submits the reserve doubling height to the contract only if the height is a new value.
+func (c *contract) UpdateHeight(ctx context.Context) (common.Hash, bool, error) {
+
+	h, err := c.getHeight(ctx)
+	if err != nil {
+		return common.Hash{}, false, fmt.Errorf("staking contract: failed to read previous height: %w", err)
+	}
+
+	if h == c.height {
+		return common.Hash{}, false, nil
+	}
+
+	receipt, err := c.sendManageStakeTransaction(ctx, new(big.Int))
+	if err != nil {
+		return common.Hash{}, false, fmt.Errorf("staking contract: failed to write new height: %w", err)
+	}
+
+	return receipt.TxHash, true, nil
+}
+
 func (c *contract) GetPotentialStake(ctx context.Context) (*big.Int, error) {
 	stakedAmount, err := c.getPotentialStake(ctx)
 	if err != nil {
@@ -295,8 +316,8 @@ func (c *contract) sendTransaction(ctx context.Context, callData []byte, desc st
 	return receipt, nil
 }
 
-func (c *contract) sendDepositStakeTransaction(ctx context.Context, stakedAmount *big.Int, nonce common.Hash) (*types.Receipt, error) {
-	callData, err := c.stakingContractABI.Pack("manageStake", nonce, stakedAmount, c.height)
+func (c *contract) sendManageStakeTransaction(ctx context.Context, stakedAmount *big.Int) (*types.Receipt, error) {
+	callData, err := c.stakingContractABI.Pack("manageStake", c.overlayNonce, stakedAmount, c.height)
 	if err != nil {
 		return nil, err
 	}
@@ -442,3 +463,28 @@ func (c *contract) paused(ctx context.Context) (bool, error) {
 
 	return results[0].(bool), nil
 }
+
+func (c *contract) getHeight(ctx context.Context) (uint8, error) {
+	callData, err := c.stakingContractABI.Pack("heightOfAddress", c.owner)
+	if err != nil {
+		return 0, err
+	}
+
+	result, err := c.transactionService.Call(ctx, &transaction.TxRequest{
+		To:   &c.stakingContractAddress,
+		Data: callData,
+	})
+	if err != nil {
+		return 0, err
+	}
+	results, err := c.stakingContractABI.Unpack("heightOfAddress", result)
+	if err != nil {
+		return 0, err
+	}
+
+	if len(results) == 0 {
+		return 0, errors.New("unexpected empty results")
+	}
+
+	return results[0].(uint8), nil
+}
diff --git a/pkg/storageincentives/staking/contract_test.go b/pkg/storageincentives/staking/contract_test.go
index 15cb84b0882..080ed13c324 100644
--- a/pkg/storageincentives/staking/contract_test.go
+++ b/pkg/storageincentives/staking/contract_test.go
@@ -564,6 +564,265 @@ func TestDepositStake(t *testing.T) {
 	})
 }
 
+func TestChangeHeight(t *testing.T) {
+	t.Parallel()
+
+	ctx := context.Background()
+	owner := common.HexToAddress("abcd")
+	stakingContractAddress := common.HexToAddress("ffff")
+	bzzTokenAddress := common.HexToAddress("eeee")
+	nonce := common.BytesToHash(make([]byte, 32))
+	txHashDeposited := common.HexToHash("c3a7")
+	stakedAmount := big.NewInt(0)
+	txHashApprove := common.HexToHash("abb0")
+
+	t.Run("ok", func(t *testing.T) {
+		t.Parallel()
+
+		expectedCallData, err := stakingContractABI.Pack("manageStake", nonce, stakedAmount, stakingHeight)
+		if err != nil {
+			t.Fatal(err)
+		}
+
+		contract := staking.New(
+			owner,
+			stakingContractAddress,
+			stakingContractABI,
+			bzzTokenAddress,
+			transactionMock.New(
+				transactionMock.WithSendFunc(func(ctx context.Context, request *transaction.TxRequest, boost int) (txHash common.Hash, err error) {
+					if *request.To == stakingContractAddress {
+						if !bytes.Equal(expectedCallData[:80], request.Data[:80]) {
+							return common.Hash{}, fmt.Errorf("got wrong call data. wanted %x, got %x", expectedCallData, request.Data)
+						}
+						return txHashDeposited, nil
+					}
+					return common.Hash{}, errors.New("sent to wrong contract")
+				}),
+				transactionMock.WithWaitForReceiptFunc(func(ctx context.Context, txHash common.Hash) (receipt *types.Receipt, err error) {
+					if txHash == txHashDeposited {
+						return &types.Receipt{
+							Status: 1,
+						}, nil
+					}
+					if txHash == txHashApprove {
+						return &types.Receipt{
+							Status: 1,
+						}, nil
+					}
+					return nil, errors.New("unknown tx hash")
+				}),
+				transactionMock.WithCallFunc(func(ctx context.Context, request *transaction.TxRequest) (result []byte, err error) {
+					if *request.To == stakingContractAddress {
+						ret := make([]byte, 32)
+						ret[1] = stakingHeight
+						return ret, nil
+					}
+					return nil, errors.New("unexpected call")
+				}),
+			),
+			nonce,
+			false,
+			stakingHeight,
+		)
+
+		_, updated, err := contract.UpdateHeight(ctx)
+		if err != nil {
+			t.Fatal(err)
+		}
+		if updated {
+			t.Fatal("expected height not to change")
+		}
+	})
+
+	t.Run("ok - height increased", func(t *testing.T) {
+		t.Parallel()
+
+		var (
+			oldHeight uint8 = 0
+			newHeight uint8 = 1
+		)
+
+		expectedCallData, err := stakingContractABI.Pack("manageStake", nonce, stakedAmount, newHeight)
+		if err != nil {
+			t.Fatal(err)
+		}
+
+		contract := staking.New(
+			owner,
+			stakingContractAddress,
+			stakingContractABI,
+			bzzTokenAddress,
+			transactionMock.New(
+				transactionMock.WithSendFunc(func(ctx context.Context, request *transaction.TxRequest, boost int) (txHash common.Hash, err error) {
+					if *request.To == stakingContractAddress {
+						if !bytes.Equal(expectedCallData[:80], request.Data[:80]) {
+							return common.Hash{}, fmt.Errorf("got wrong call data. wanted %x, got %x", expectedCallData, request.Data)
+						}
+						return txHashDeposited, nil
+					}
+					return common.Hash{}, errors.New("sent to wrong contract")
+				}),
+				transactionMock.WithWaitForReceiptFunc(func(ctx context.Context, txHash common.Hash) (receipt *types.Receipt, err error) {
+					if txHash == txHashDeposited {
+						return &types.Receipt{
+							Status: 1,
+						}, nil
+					}
+					if txHash == txHashApprove {
+						return &types.Receipt{
+							Status: 1,
+						}, nil
+					}
+					return nil, errors.New("unknown tx hash")
+				}),
+				transactionMock.WithCallFunc(func(ctx context.Context, request *transaction.TxRequest) (result []byte, err error) {
+					if *request.To == stakingContractAddress {
+						ret := make([]byte, 32)
+						ret[31] = oldHeight
+						return ret, nil
+					}
+					return nil, errors.New("unexpected call")
+				}),
+			),
+			nonce,
+			false,
+			newHeight,
+		)
+
+		_, updated, err := contract.UpdateHeight(ctx)
+		if err != nil {
+			t.Fatal(err)
+		}
+		if !updated {
+			t.Fatal("expected height to change")
+		}
+	})
+
+	t.Run("ok - height decreased", func(t *testing.T) {
+		t.Parallel()
+
+		var (
+			oldHeight uint8 = 1
+			newHeight uint8 = 0
+		)
+
+		expectedCallData, err := stakingContractABI.Pack("manageStake", nonce, stakedAmount, newHeight)
+		if err != nil {
+			t.Fatal(err)
+		}
+
+		contract := staking.New(
+			owner,
+			stakingContractAddress,
+			stakingContractABI,
+			bzzTokenAddress,
+			transactionMock.New(
+				transactionMock.WithSendFunc(func(ctx context.Context, request *transaction.TxRequest, boost int) (txHash common.Hash, err error) {
+					if *request.To == stakingContractAddress {
+						if !bytes.Equal(expectedCallData[:80], request.Data[:80]) {
+							return common.Hash{}, fmt.Errorf("got wrong call data. wanted %x, got %x", expectedCallData, request.Data)
+						}
+						return txHashDeposited, nil
+					}
+					return common.Hash{}, errors.New("sent to wrong contract")
+				}),
+				transactionMock.WithWaitForReceiptFunc(func(ctx context.Context, txHash common.Hash) (receipt *types.Receipt, err error) {
+					if txHash == txHashDeposited {
+						return &types.Receipt{
+							Status: 1,
+						}, nil
+					}
+					if txHash == txHashApprove {
+						return &types.Receipt{
+							Status: 1,
+						}, nil
+					}
+					return nil, errors.New("unknown tx hash")
+				}),
+				transactionMock.WithCallFunc(func(ctx context.Context, request *transaction.TxRequest) (result []byte, err error) {
+					if *request.To == stakingContractAddress {
+						ret := make([]byte, 32)
+						ret[31] = oldHeight
+						return ret, nil
+					}
+					return nil, errors.New("unexpected call")
+				}),
+			),
+			nonce,
+			false,
+			newHeight,
+		)
+
+		_, updated, err := contract.UpdateHeight(ctx)
+		if err != nil {
+			t.Fatal(err)
+		}
+		if !updated {
+			t.Fatal("expected height to change")
+		}
+	})
+
+	t.Run("send tx failed", func(t *testing.T) {
+		t.Parallel()
+
+		prevStake := big.NewInt(0)
+
+		contract := staking.New(
+			owner,
+			stakingContractAddress,
+			stakingContractABI,
+			bzzTokenAddress,
+			transactionMock.New(
+				transactionMock.WithSendFunc(func(ctx context.Context, request *transaction.TxRequest, boost int) (txHash common.Hash, err error) {
+					return common.Hash{}, errors.New("sent to wrong contract")
+				}),
+				transactionMock.WithCallFunc(func(ctx context.Context, request *transaction.TxRequest) (result []byte, err error) {
+					if *request.To == stakingContractAddress {
+						return prevStake.FillBytes(make([]byte, 32)), nil
+					}
+					return nil, errors.New("unexpected call")
+				}),
+			),
+			nonce,
+			false,
+			stakingHeight,
+		)
+
+		_, err := contract.DepositStake(ctx, stakedAmount)
+		if err == nil {
+			t.Fatal("expected error")
+		}
+	})
+
+	t.Run("transaction error in call", func(t *testing.T) {
+		t.Parallel()
+
+		contract := staking.New(
+			owner,
+			stakingContractAddress,
+			stakingContractABI,
+			bzzTokenAddress,
+			transactionMock.New(
+				transactionMock.WithCallFunc(func(ctx context.Context, request *transaction.TxRequest) (result []byte, err error) {
+					if *request.To == stakingContractAddress {
+						return nil, errors.New("some error")
+					}
+					return nil, errors.New("unexpected call")
+				}),
+			),
+			nonce,
+			false,
+			stakingHeight,
+		)
+
+		_, _, err := contract.UpdateHeight(ctx)
+		if err == nil {
+			t.Fatalf("expected error")
+		}
+	})
+}
+
 func TestChangeStakeOverlay(t *testing.T) {
 	t.Parallel()
 
diff --git a/pkg/storageincentives/staking/mock/contract.go b/pkg/storageincentives/staking/mock/contract.go
index 93fab73f937..131de14dba6 100644
--- a/pkg/storageincentives/staking/mock/contract.go
+++ b/pkg/storageincentives/staking/mock/contract.go
@@ -28,6 +28,10 @@ func (s *stakingContractMock) ChangeStakeOverlay(_ context.Context, h common.Has
 	return h, nil
 }
 
+func (s *stakingContractMock) UpdateHeight(_ context.Context) (common.Hash, bool, error) {
+	return common.Hash{}, false, nil
+}
+
 func (s *stakingContractMock) GetPotentialStake(ctx context.Context) (*big.Int, error) {
 	return s.getStake(ctx)
 }