diff --git a/config/toml.go b/config/toml.go
index 7eb8bcc845..3f1d27467e 100644
--- a/config/toml.go
+++ b/config/toml.go
@@ -664,9 +664,7 @@ const testGenesisFmt = `{
 			"propose": "30000000",
 			"propose_delta": "50000",
 			"vote": "30000000",
-			"vote_delta": "50000",
-			"commit": "10000000",
-			"bypass_timeout_commit": true
+			"vote_delta": "50000"
 		},
 		"evidence": {
 			"max_age_num_blocks": "100000",
diff --git a/internal/consensus/block_executor.go b/internal/consensus/block_executor.go
index 6a0e768857..e6a90098e4 100644
--- a/internal/consensus/block_executor.go
+++ b/internal/consensus/block_executor.go
@@ -42,7 +42,6 @@ func (c *blockExecutor) create(ctx context.Context, rs *cstypes.RoundState, roun
 		// The commit is empty, but not nil.
 		commit = types.NewCommit(0, 0, types.BlockID{}, nil, nil)
 	case rs.LastCommit != nil:
-		// Make the commit from LastPrecommits
 		commit = rs.LastCommit
 
 	default: // This shouldn't happen.
diff --git a/internal/consensus/gossiper.go b/internal/consensus/gossiper.go
index 4a3dc5991c..c1ec94adb0 100644
--- a/internal/consensus/gossiper.go
+++ b/internal/consensus/gossiper.go
@@ -311,10 +311,6 @@ func (g *msgGossiper) ensurePeerPartSetHeader(blockPartSetHeader types.PartSetHe
 // there is a vote to send and (nil,false) otherwise.
 func (g *msgGossiper) pickVoteForGossip(rs cstypes.RoundState, prs *cstypes.PeerRoundState) (*types.Vote, bool) {
 	var voteSets []*types.VoteSet
-	// if there are lastPrecommits to send
-	if prs.Step == cstypes.RoundStepNewHeight {
-		voteSets = append(voteSets, rs.LastPrecommits)
-	}
 	if prs.Round != -1 && prs.Round <= rs.Round {
 		// if there are POL prevotes to send
 		if prs.Step <= cstypes.RoundStepPropose && prs.ProposalPOLRound != -1 {
diff --git a/internal/consensus/gossiper_test.go b/internal/consensus/gossiper_test.go
index 7007b31b2c..fdfb30e440 100644
--- a/internal/consensus/gossiper_test.go
+++ b/internal/consensus/gossiper_test.go
@@ -470,10 +470,6 @@ func (suite *GossiperSuiteTest) TestGossipGossipVote() {
 	ctx, cancel := context.WithCancel(context.Background())
 	defer cancel()
 
-	precommitH99 := suite.makeSignedVote(99, 0, tmproto.PrecommitType)
-	lastPercommits := types.NewVoteSet(factory.DefaultTestChainID, 99, 0, tmproto.PrecommitType, suite.valSet)
-	_, _ = lastPercommits.AddVote(precommitH99)
-
 	prevoteH100R0 := suite.makeSignedVote(100, 0, tmproto.PrevoteType)
 	prevoteH100R1 := suite.makeSignedVote(100, 1, tmproto.PrevoteType)
 	prevoteH100R2 := suite.makeSignedVote(100, 2, tmproto.PrevoteType)
@@ -489,16 +485,6 @@ func (suite *GossiperSuiteTest) TestGossipGossipVote() {
 		prs     cstypes.PeerRoundState
 		wantMsg *tmproto.Vote
 	}{
-		{
-			rs: cstypes.RoundState{LastPrecommits: lastPercommits},
-			prs: cstypes.PeerRoundState{
-				Height:           100,
-				Round:            -1,
-				ProposalPOLRound: -1,
-				Step:             cstypes.RoundStepNewHeight,
-			},
-			wantMsg: precommitH99.ToProto(),
-		},
 		{
 			rs: cstypes.RoundState{Votes: votesH100},
 			prs: cstypes.PeerRoundState{
diff --git a/internal/consensus/msg_handlers.go b/internal/consensus/msg_handlers.go
index 282becf5ef..3f25c3556c 100644
--- a/internal/consensus/msg_handlers.go
+++ b/internal/consensus/msg_handlers.go
@@ -185,13 +185,6 @@ func msgInfoWithCtxMiddleware() msgMiddlewareFunc {
 	}
 }
 
-func logKeyValsWithError(keyVals []any, err error) []any {
-	if err == nil {
-		return keyVals
-	}
-	return append(keyVals, "error", err)
-}
-
 func makeLogArgsFromMessage(msg Message) []any {
 	switch m := msg.(type) {
 	case *ProposalMessage:
diff --git a/internal/consensus/peer_state.go b/internal/consensus/peer_state.go
index 607fc3be86..a060fc8104 100644
--- a/internal/consensus/peer_state.go
+++ b/internal/consensus/peer_state.go
@@ -268,7 +268,7 @@ func (ps *PeerState) getVoteBitArray(height int64, round int32, votesType tmprot
 				return nil
 
 			case tmproto.PrecommitType:
-				return ps.PRS.LastPrecommits
+				return ps.PRS.Precommits
 			}
 		}
 
@@ -335,10 +335,6 @@ func (ps *PeerState) ensureVoteBitArrays(height int64, numValidators int) {
 		if ps.PRS.ProposalPOL == nil {
 			ps.PRS.ProposalPOL = bits.NewBitArray(numValidators)
 		}
-	} else if ps.PRS.Height == height+1 {
-		if ps.PRS.LastPrecommits == nil {
-			ps.PRS.LastPrecommits = bits.NewBitArray(numValidators)
-		}
 	}
 }
 
@@ -530,10 +526,8 @@ func (ps *PeerState) ApplyNewRoundStepMessage(msg *NewRoundStepMessage) {
 		// Shift Precommits to LastPrecommits.
 		if psHeight+1 == msg.Height && psRound == msg.LastCommitRound {
 			ps.PRS.LastCommitRound = msg.LastCommitRound
-			ps.PRS.LastPrecommits = ps.PRS.Precommits.Copy()
 		} else {
 			ps.PRS.LastCommitRound = msg.LastCommitRound
-			ps.PRS.LastPrecommits = nil
 		}
 
 		// we'll update the BitArray capacity later
diff --git a/internal/consensus/reactor.go b/internal/consensus/reactor.go
index d16e1c3543..48499df38b 100644
--- a/internal/consensus/reactor.go
+++ b/internal/consensus/reactor.go
@@ -682,7 +682,8 @@ func (r *Reactor) handleVoteMessage(ctx context.Context, envelope *p2p.Envelope,
 	case *tmcons.Vote:
 		stateData := r.state.stateDataStore.Get()
 		isValidator := stateData.isValidator(r.state.privValidator.ProTxHash)
-		height, valSize, lastCommitSize := stateData.Height, stateData.Validators.Size(), stateData.LastPrecommits.Size()
+		height, valSize := stateData.Height, stateData.Validators.Size()
+		lastValSize := len(stateData.LastValidators.Validators)
 
 		if isValidator { // ignore votes on non-validator nodes; TODO don't even send it
 			vMsg := msgI.(*VoteMessage)
@@ -692,7 +693,7 @@ func (r *Reactor) handleVoteMessage(ctx context.Context, envelope *p2p.Envelope,
 			}
 
 			ps.EnsureVoteBitArrays(height, valSize)
-			ps.EnsureVoteBitArrays(height-1, lastCommitSize)
+			ps.EnsureVoteBitArrays(height-1, lastValSize)
 			if err := ps.SetHasVote(vMsg.Vote); err != nil {
 				return err
 			}
diff --git a/internal/consensus/reactor_test.go b/internal/consensus/reactor_test.go
index 8d51c51e2f..b5a0a03a39 100644
--- a/internal/consensus/reactor_test.go
+++ b/internal/consensus/reactor_test.go
@@ -556,7 +556,6 @@ func TestReactorValidatorSetChanges(t *testing.T) {
 		validatorUpdates: updates,
 		consensusParams: factory.ConsensusParams(func(cp *types.ConsensusParams) {
 			cp.Timeout.Propose = 2 * time.Second
-			cp.Timeout.Commit = 1 * time.Second
 			cp.Timeout.Vote = 1 * time.Second
 		}),
 	}
diff --git a/internal/consensus/state.go b/internal/consensus/state.go
index 91af6fac30..edf21edf12 100644
--- a/internal/consensus/state.go
+++ b/internal/consensus/state.go
@@ -512,8 +512,9 @@ func (cs *State) OnStop() {
 	if cs.GetRoundState().Step == cstypes.RoundStepApplyCommit {
 		select {
 		case <-cs.getOnStopCh():
-		case <-time.After(stateData.state.ConsensusParams.Timeout.Commit):
-			cs.logger.Error("OnStop: timeout waiting for commit to finish", "time", stateData.state.ConsensusParams.Timeout.Commit)
+		case <-time.After(stateData.state.ConsensusParams.Timeout.Vote):
+			// we wait vote timeout, just in case
+			cs.logger.Error("OnStop: timeout waiting for commit to finish", "time", stateData.state.ConsensusParams.Timeout.Vote)
 		}
 	}
 
diff --git a/internal/consensus/state_add_commit.go b/internal/consensus/state_add_commit.go
index 17981f909f..3cfcfe70d4 100644
--- a/internal/consensus/state_add_commit.go
+++ b/internal/consensus/state_add_commit.go
@@ -47,9 +47,10 @@ func (c *AddCommitAction) Execute(ctx context.Context, stateEvent StateEvent) er
 	if err != nil {
 		return fmt.Errorf("error adding commit: %w", err)
 	}
-	if stateData.bypassCommitTimeout() {
-		_ = stateEvent.Ctrl.Dispatch(ctx, &EnterNewRoundEvent{Height: stateData.Height}, stateData)
-	}
+
+	// We go to next round, as in Tenderdash we don't need to wait for new commits
+	_ = stateEvent.Ctrl.Dispatch(ctx, &EnterNewRoundEvent{Height: stateData.Height}, stateData)
+
 	_ = c.statsQueue.send(ctx, msgInfoFromCtx(ctx))
 	return nil
 }
diff --git a/internal/consensus/state_add_vote.go b/internal/consensus/state_add_vote.go
index 26fc4c87f1..d97fbf95cb 100644
--- a/internal/consensus/state_add_vote.go
+++ b/internal/consensus/state_add_vote.go
@@ -45,7 +45,6 @@ func newAddVoteAction(cs *State, ctrl *Controller, statsQueue *chanQueue[msgInfo
 	statsMw := addVoteStatsMw(statsQueue)
 	dispatchPrecommitMw := addVoteDispatchPrecommitMw(ctrl)
 	verifyVoteExtensionMw := addVoteVerifyVoteExtensionMw(cs.privValidator, cs.blockExec, cs.metrics, cs.emitter)
-	addToLastPrecommitMw := addVoteToLastPrecommitMw(cs.eventPublisher, ctrl)
 	return &AddVoteAction{
 		prevote: withVoterMws(
 			addToVoteSet,
@@ -62,7 +61,6 @@ func newAddVoteAction(cs *State, ctrl *Controller, statsQueue *chanQueue[msgInfo
 			dispatchPrecommitMw,
 			verifyVoteExtensionMw,
 			validateVoteMw,
-			addToLastPrecommitMw,
 			errorMw,
 			statsMw,
 		),
@@ -101,45 +99,6 @@ func addVoteToVoteSetFunc(metrics *Metrics, ep *EventPublisher) AddVoteFunc {
 	}
 }
 
-func addVoteToLastPrecommitMw(ep *EventPublisher, ctrl *Controller) AddVoteMiddlewareFunc {
-	return func(next AddVoteFunc) AddVoteFunc {
-		return func(ctx context.Context, stateData *StateData, vote *types.Vote) (bool, error) {
-			if vote.Height+1 != stateData.Height || vote.Type != tmproto.PrecommitType {
-				return next(ctx, stateData, vote)
-			}
-			logger := log.FromCtxOrNop(ctx)
-			if stateData.Step != cstypes.RoundStepNewHeight {
-				// Late precommit at prior height is ignored
-				logger.Trace("precommit vote came in after commit timeout and has been ignored")
-				return false, nil
-			}
-			if stateData.LastPrecommits == nil {
-				logger.Debug("no last round precommits on node", "vote", vote)
-				return false, nil
-			}
-			added, err := stateData.LastPrecommits.AddVote(vote)
-			if !added {
-				logger.Debug("vote not added to last precommits", logKeyValsWithError(nil, err)...)
-				return false, nil
-			}
-			logger.Trace("added vote to last precommits", "last_precommits", stateData.LastPrecommits)
-
-			err = ep.PublishVoteEvent(vote)
-			if err != nil {
-				return added, err
-			}
-
-			// if we can skip timeoutCommit and have all the votes now,
-			if stateData.bypassCommitTimeout() && stateData.LastPrecommits.HasAll() {
-				// go straight to new round (skip timeout commit)
-				// c.scheduleTimeout(time.Duration(0), c.Height, 0, cstypes.RoundStepNewHeight)
-				_ = ctrl.Dispatch(ctx, &EnterNewRoundEvent{Height: stateData.Height}, stateData)
-			}
-			return added, err
-		}
-	}
-}
-
 func addVoteUpdateValidBlockMw(ep *EventPublisher) AddVoteMiddlewareFunc {
 	return func(next AddVoteFunc) AddVoteFunc {
 		return func(ctx context.Context, stateData *StateData, vote *types.Vote) (bool, error) {
@@ -250,7 +209,7 @@ func addVoteDispatchPrecommitMw(ctrl *Controller) AddVoteMiddlewareFunc {
 				return added, err
 			}
 			_ = ctrl.Dispatch(ctx, &EnterCommitEvent{Height: height, CommitRound: vote.Round}, stateData)
-			if stateData.bypassCommitTimeout() && precommits.HasAll() {
+			if precommits.HasTwoThirdsMajority() {
 				_ = ctrl.Dispatch(ctx, &EnterNewRoundEvent{Height: stateData.Height}, stateData)
 			}
 			return added, err
diff --git a/internal/consensus/state_data.go b/internal/consensus/state_data.go
index 519d60175a..edc5b038ea 100644
--- a/internal/consensus/state_data.go
+++ b/internal/consensus/state_data.go
@@ -226,7 +226,6 @@ func (s *StateData) updateToState(state sm.State, commit *types.Commit) {
 	switch {
 	case state.LastBlockHeight == 0: // Very first commit should be empty.
 		s.LastCommit = (*types.Commit)(nil)
-		s.LastPrecommits = (*types.VoteSet)(nil)
 	case s.CommitRound > -1 && s.Votes != nil && commit == nil: // Otherwise, use cs.Votes
 		if !s.Votes.Precommits(s.CommitRound).HasTwoThirdsMajority() {
 			panic(fmt.Sprintf(
@@ -234,14 +233,9 @@ func (s *StateData) updateToState(state sm.State, commit *types.Commit) {
 				state.LastBlockHeight, s.CommitRound, s.Votes.Precommits(s.CommitRound),
 			))
 		}
-		s.LastPrecommits = s.Votes.Precommits(s.CommitRound)
-		s.LastCommit = s.LastPrecommits.MakeCommit()
+		precommits := s.Votes.Precommits(s.CommitRound)
+		s.LastCommit = precommits.MakeCommit()
 	case commit != nil:
-		// We either got the commit from a remote node
-		// In which Last precommits will be nil
-		// Or we got the commit from finalize commit
-		// In which Last precommits will not be nil
-		s.LastPrecommits = s.Votes.Precommits(s.CommitRound)
 		s.LastCommit = commit
 	case s.LastCommit == nil:
 		// NOTE: when Tendermint starts, it has no votes. reconstructLastCommit
@@ -266,13 +260,9 @@ func (s *StateData) updateToState(state sm.State, commit *types.Commit) {
 
 	if s.CommitTime.IsZero() {
 		// "Now" makes it easier to sync up dev nodes.
-		// We add timeoutCommit to allow transactions
-		// to be gathered for the first block.
-		// And alternative solution that relies on clocks:
-		// cs.StartTime = state.LastBlockTime.Add(timeoutCommit)
-		s.StartTime = s.commitTime(tmtime.Now())
+		s.StartTime = tmtime.Now()
 	} else {
-		s.StartTime = s.commitTime(s.CommitTime)
+		s.StartTime = s.CommitTime
 	}
 
 	if s.Validators == nil || !bytes.Equal(s.Validators.QuorumHash, validators.QuorumHash) {
@@ -314,14 +304,6 @@ func (s *StateData) HeightVoteSet() (int64, *cstypes.HeightVoteSet) {
 	return s.Height, s.Votes
 }
 
-func (s *StateData) commitTime(t time.Time) time.Time {
-	c := s.state.ConsensusParams.Timeout.Commit
-	if s.config.UnsafeCommitTimeoutOverride != 0 {
-		c = s.config.UnsafeProposeTimeoutOverride
-	}
-	return t.Add(c)
-}
-
 func (s *StateData) proposalIsTimely() bool {
 	if s.Height == s.state.InitialHeight {
 		// by definition, initial block must have genesis time
@@ -459,13 +441,6 @@ func (s *StateData) voteTimeout(round int32) time.Duration {
 	) * time.Nanosecond
 }
 
-func (s *StateData) bypassCommitTimeout() bool {
-	if s.config.UnsafeBypassCommitTimeoutOverride != nil {
-		return *s.config.UnsafeBypassCommitTimeoutOverride
-	}
-	return s.state.ConsensusParams.Timeout.BypassCommitTimeout
-}
-
 func (s *StateData) isValidForPrevote() error {
 	// Check that a proposed block was not received within this round (and thus executing this from a timeout).
 	if s.ProposalBlock == nil {
diff --git a/internal/consensus/state_test.go b/internal/consensus/state_test.go
index e6420a1b30..ea3cda10af 100644
--- a/internal/consensus/state_test.go
+++ b/internal/consensus/state_test.go
@@ -2733,7 +2733,6 @@ func TestStartNextHeightCorrectlyAfterTimeout(t *testing.T) {
 
 	cs1, vss := makeState(ctx, t, makeStateArgs{config: config})
 	stateData := cs1.GetStateData()
-	stateData.state.ConsensusParams.Timeout.BypassCommitTimeout = false
 	err := stateData.Save()
 	require.NoError(t, err)
 	cs1.txNotifier = &fakeTxNotifier{ch: make(chan struct{})}
@@ -2798,7 +2797,6 @@ func TestResetTimeoutPrecommitUponNewHeight(t *testing.T) {
 
 	cs1, vss := makeState(ctx, t, makeStateArgs{config: config})
 	stateData := cs1.GetStateData()
-	stateData.state.ConsensusParams.Timeout.BypassCommitTimeout = false
 	err := stateData.Save()
 	require.NoError(t, err)
 
diff --git a/internal/consensus/types/peer_round_state.go b/internal/consensus/types/peer_round_state.go
index e5e2e3e6fb..4649e8f9af 100644
--- a/internal/consensus/types/peer_round_state.go
+++ b/internal/consensus/types/peer_round_state.go
@@ -34,7 +34,6 @@ type PeerRoundState struct {
 	Prevotes        *bits.BitArray `json:"prevotes"`          // All votes peer has for this round
 	Precommits      *bits.BitArray `json:"precommits"`        // All precommits peer has for this round
 	LastCommitRound int32          `json:"last_commit_round"` // Round of commit for last height. -1 if none.
-	LastPrecommits  *bits.BitArray `json:"last_commit"`       // All commit precommits of commit for last height.
 
 	HasCommit bool `json:"has_commit"`
 
@@ -69,7 +68,6 @@ func (prs PeerRoundState) Copy() PeerRoundState {
 	prs.ProposalPOL = prs.ProposalPOL.Copy()
 	prs.Prevotes = prs.Prevotes.Copy()
 	prs.Precommits = prs.Precommits.Copy()
-	prs.LastPrecommits = prs.LastPrecommits.Copy()
 	prs.CatchupCommit = prs.CatchupCommit.Copy()
 
 	return prs
@@ -83,7 +81,7 @@ func (prs PeerRoundState) StringIndented(indent string) string {
 %s  POL      %v (round %v)
 %s  Prevotes   %v
 %s  Precommits %v
-%s  LastPrecommits %v (round %v)
+%s  Last commit round %v
 %s  Catchup    %v (round %v)
 %s}`,
 		indent, prs.Height, prs.Round, prs.Step, prs.StartTime,
@@ -91,7 +89,7 @@ func (prs PeerRoundState) StringIndented(indent string) string {
 		indent, prs.ProposalPOL, prs.ProposalPOLRound,
 		indent, prs.Prevotes,
 		indent, prs.Precommits,
-		indent, prs.LastPrecommits, prs.LastCommitRound,
+		indent, prs.LastCommitRound,
 		indent, prs.CatchupCommit, prs.CatchupCommitRound,
 		indent)
 }
diff --git a/internal/consensus/types/round_state.go b/internal/consensus/types/round_state.go
index 8c9181b9a0..1e93d8d8c7 100644
--- a/internal/consensus/types/round_state.go
+++ b/internal/consensus/types/round_state.go
@@ -103,7 +103,6 @@ type RoundState struct {
 	ValidBlockParts           *types.PartSet      `json:"valid_block_parts"`
 	Votes                     *HeightVoteSet      `json:"votes"`
 	CommitRound               int32               `json:"commit_round"`
-	LastPrecommits            *types.VoteSet      `json:"last_precommits"`
 	LastCommit                *types.Commit       `json:"last_commit"`
 	LastValidators            *types.ValidatorSet `json:"last_validators"`
 	TriggeredTimeoutPrecommit bool                `json:"triggered_timeout_precommit"`
diff --git a/internal/state/state_test.go b/internal/state/state_test.go
index 7d77af19ca..ebf3d17701 100644
--- a/internal/state/state_test.go
+++ b/internal/state/state_test.go
@@ -1100,20 +1100,22 @@ func TestStateProto(t *testing.T) {
 
 	for _, tt := range tc {
 		tt := tt
-		pbs, err := tt.state.ToProto()
-		if !tt.expPass1 {
-			assert.Error(t, err)
-		} else {
-			assert.NoError(t, err, tt.testName)
-		}
+		t.Run(tt.testName, func(t *testing.T) {
+			pbs, err := tt.state.ToProto()
+			if !tt.expPass1 {
+				assert.Error(t, err)
+			} else {
+				assert.NoError(t, err, tt.testName)
+			}
 
-		smt, err := sm.FromProto(pbs)
-		if tt.expPass2 {
-			require.NoError(t, err, tt.testName)
-			require.Equal(t, tt.state, smt, tt.testName)
-		} else {
-			require.Error(t, err, tt.testName)
-		}
+			smt, err := sm.FromProto(pbs)
+			if tt.expPass2 {
+				require.NoError(t, err, tt.testName)
+				require.Equal(t, tt.state, smt, tt.testName)
+			} else {
+				require.Error(t, err, tt.testName)
+			}
+		})
 	}
 }
 
diff --git a/internal/test/factory/params.go b/internal/test/factory/params.go
index dcbe137a2e..b4d73727c4 100644
--- a/internal/test/factory/params.go
+++ b/internal/test/factory/params.go
@@ -11,12 +11,10 @@ import (
 func ConsensusParams(opts ...func(*types.ConsensusParams)) *types.ConsensusParams {
 	c := types.DefaultConsensusParams()
 	c.Timeout = types.TimeoutParams{
-		Commit:              10 * time.Millisecond,
-		Propose:             40 * time.Millisecond,
-		ProposeDelta:        1 * time.Millisecond,
-		Vote:                10 * time.Millisecond,
-		VoteDelta:           1 * time.Millisecond,
-		BypassCommitTimeout: true,
+		Propose:      40 * time.Millisecond,
+		ProposeDelta: 1 * time.Millisecond,
+		Vote:         10 * time.Millisecond,
+		VoteDelta:    1 * time.Millisecond,
 	}
 	for _, opt := range opts {
 		opt(c)
diff --git a/proto/tendermint/types/params.pb.go b/proto/tendermint/types/params.pb.go
index 1d48708289..e8573e5a47 100644
--- a/proto/tendermint/types/params.pb.go
+++ b/proto/tendermint/types/params.pb.go
@@ -487,16 +487,6 @@ type TimeoutParams struct {
 	// to the next step immediately.
 	Vote      *time.Duration `protobuf:"bytes,3,opt,name=vote,proto3,stdduration" json:"vote,omitempty"`
 	VoteDelta *time.Duration `protobuf:"bytes,4,opt,name=vote_delta,json=voteDelta,proto3,stdduration" json:"vote_delta,omitempty"`
-	// commit configures how long Tendermint will wait after receiving a quorum of
-	// precommits before beginning consensus for the next height. This can be
-	// used to allow slow precommits to arrive for inclusion in the next height before progressing.
-	Commit *time.Duration `protobuf:"bytes,5,opt,name=commit,proto3,stdduration" json:"commit,omitempty"`
-	// bypass_commit_timeout configures the node to proceed immediately to
-	// the next height once the node has received all precommits for a block, forgoing
-	// the remaining commit timeout.
-	// Setting bypass_commit_timeout false (the default) causes Tendermint to wait
-	// for the full commit timeout.
-	BypassCommitTimeout bool `protobuf:"varint,6,opt,name=bypass_commit_timeout,json=bypassCommitTimeout,proto3" json:"bypass_commit_timeout,omitempty"`
 }
 
 func (m *TimeoutParams) Reset()         { *m = TimeoutParams{} }
@@ -560,20 +550,6 @@ func (m *TimeoutParams) GetVoteDelta() *time.Duration {
 	return nil
 }
 
-func (m *TimeoutParams) GetCommit() *time.Duration {
-	if m != nil {
-		return m.Commit
-	}
-	return nil
-}
-
-func (m *TimeoutParams) GetBypassCommitTimeout() bool {
-	if m != nil {
-		return m.BypassCommitTimeout
-	}
-	return false
-}
-
 // ABCIParams configure functionality specific to the Application Blockchain Interface.
 type ABCIParams struct {
 	// Indicates if CheckTx should be called on all the transactions
@@ -636,53 +612,53 @@ func init() {
 func init() { proto.RegisterFile("tendermint/types/params.proto", fileDescriptor_e12598271a686f57) }
 
 var fileDescriptor_e12598271a686f57 = []byte{
-	// 731 bytes of a gzipped FileDescriptorProto
-	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x8c, 0x95, 0xcf, 0x6e, 0xd3, 0x4a,
-	0x14, 0xc6, 0xe3, 0x26, 0x4d, 0x93, 0x93, 0xa6, 0xa9, 0xe6, 0xde, 0xab, 0xeb, 0xdb, 0x4b, 0x9d,
-	0xe2, 0x05, 0xaa, 0x54, 0xc9, 0xae, 0x5a, 0x10, 0x42, 0xe2, 0x8f, 0x9a, 0x04, 0x01, 0x42, 0x45,
-	0xc8, 0x54, 0x2c, 0xba, 0xb1, 0xc6, 0xce, 0xe0, 0x58, 0x8d, 0x3d, 0x96, 0xc7, 0x8e, 0xe2, 0xb7,
-	0x60, 0x85, 0x78, 0x04, 0xd8, 0xf0, 0x1c, 0x5d, 0x76, 0xc9, 0x0a, 0x50, 0xfa, 0x06, 0x3c, 0x01,
-	0x9a, 0xf1, 0xb8, 0x69, 0x52, 0x4a, 0xb3, 0x8a, 0x3d, 0xe7, 0xfb, 0xf9, 0xf3, 0x7c, 0xe7, 0x78,
-	0x02, 0x9b, 0x09, 0x09, 0xfb, 0x24, 0x0e, 0xfc, 0x30, 0x31, 0x93, 0x2c, 0x22, 0xcc, 0x8c, 0x70,
-	0x8c, 0x03, 0x66, 0x44, 0x31, 0x4d, 0x28, 0x5a, 0x9f, 0x96, 0x0d, 0x51, 0xde, 0xf8, 0xdb, 0xa3,
-	0x1e, 0x15, 0x45, 0x93, 0x5f, 0xe5, 0xba, 0x0d, 0xcd, 0xa3, 0xd4, 0x1b, 0x12, 0x53, 0xdc, 0x39,
-	0xe9, 0x3b, 0xb3, 0x9f, 0xc6, 0x38, 0xf1, 0x69, 0x98, 0xd7, 0xf5, 0x2f, 0x65, 0x68, 0x75, 0x69,
-	0xc8, 0x48, 0xc8, 0x52, 0xf6, 0x5a, 0x38, 0xa0, 0x7d, 0x58, 0x76, 0x86, 0xd4, 0x3d, 0x51, 0x95,
-	0x2d, 0x65, 0xbb, 0xb1, 0xb7, 0x69, 0xcc, 0x7b, 0x19, 0x1d, 0x5e, 0xce, 0xd5, 0x56, 0xae, 0x45,
-	0x0f, 0xa1, 0x46, 0x46, 0x7e, 0x9f, 0x84, 0x2e, 0x51, 0x97, 0x04, 0xb7, 0x75, 0x95, 0x7b, 0x2a,
-	0x15, 0x12, 0xbd, 0x20, 0xd0, 0x13, 0xa8, 0x8f, 0xf0, 0xd0, 0xef, 0xe3, 0x84, 0xc6, 0x6a, 0x59,
-	0xe0, 0xb7, 0xaf, 0xe2, 0x6f, 0x0b, 0x89, 0xe4, 0xa7, 0x0c, 0x7a, 0x00, 0x2b, 0x23, 0x12, 0x33,
-	0x9f, 0x86, 0x6a, 0x45, 0xe0, 0xed, 0xdf, 0xe0, 0xb9, 0x40, 0xc2, 0x85, 0x9e, 0x7b, 0xb3, 0x2c,
-	0x74, 0x07, 0x31, 0x0d, 0x33, 0x75, 0xf9, 0x3a, 0xef, 0x37, 0x85, 0xa4, 0xf0, 0xbe, 0x60, 0xb8,
-	0x77, 0xe2, 0x07, 0x84, 0xa6, 0x89, 0x5a, 0xbd, 0xce, 0xfb, 0x28, 0x17, 0x14, 0xde, 0x52, 0x8f,
-	0x76, 0xa1, 0x82, 0x1d, 0xd7, 0x57, 0x57, 0x04, 0x77, 0xeb, 0x2a, 0x77, 0xd0, 0xe9, 0xbe, 0x90,
-	0x90, 0x50, 0xea, 0x5d, 0x68, 0x5c, 0x4a, 0x1f, 0xfd, 0x0f, 0xf5, 0x00, 0x8f, 0x6d, 0x27, 0x4b,
-	0x08, 0x13, 0xfd, 0x2a, 0x5b, 0xb5, 0x00, 0x8f, 0x3b, 0xfc, 0x1e, 0xfd, 0x0b, 0x2b, 0xbc, 0xe8,
-	0x61, 0x26, 0x5a, 0x52, 0xb6, 0xaa, 0x01, 0x1e, 0x3f, 0xc3, 0x4c, 0xff, 0xac, 0xc0, 0xda, 0x6c,
-	0x2f, 0xd0, 0x0e, 0x20, 0xae, 0xc5, 0x1e, 0xb1, 0xc3, 0x34, 0xb0, 0x45, 0x53, 0x8b, 0x27, 0xb6,
-	0x02, 0x3c, 0x3e, 0xf0, 0xc8, 0xab, 0x34, 0x10, 0xd6, 0x0c, 0x1d, 0xc2, 0x7a, 0x21, 0x2e, 0xe6,
-	0x49, 0x36, 0xfd, 0x3f, 0x23, 0x1f, 0x38, 0xa3, 0x18, 0x38, 0xa3, 0x27, 0x05, 0x9d, 0xda, 0xe9,
-	0xb7, 0x76, 0xe9, 0xe3, 0xf7, 0xb6, 0x62, 0xad, 0xe5, 0xcf, 0x2b, 0x2a, 0xb3, 0x9b, 0x28, 0xcf,
-	0x6e, 0x42, 0xbf, 0x07, 0xad, 0xb9, 0xbe, 0x23, 0x1d, 0x9a, 0x51, 0xea, 0xd8, 0x27, 0x24, 0xb3,
-	0x45, 0x4a, 0xaa, 0xb2, 0x55, 0xde, 0xae, 0x5b, 0x8d, 0x28, 0x75, 0x5e, 0x92, 0xec, 0x88, 0x2f,
-	0xe9, 0xbb, 0xd0, 0x9c, 0xe9, 0x37, 0x6a, 0x43, 0x03, 0x47, 0x91, 0x5d, 0x4c, 0x09, 0xdf, 0x59,
-	0xc5, 0x02, 0x1c, 0x45, 0x52, 0xa6, 0x1f, 0xc3, 0xea, 0x73, 0xcc, 0x06, 0xa4, 0x2f, 0x81, 0x3b,
-	0xd0, 0x12, 0x29, 0xd8, 0xf3, 0x01, 0x37, 0xc5, 0xf2, 0x61, 0x91, 0xb2, 0x0e, 0xcd, 0xa9, 0x6e,
-	0x9a, 0x75, 0xa3, 0x50, 0xf1, 0xc0, 0x3f, 0x28, 0xd0, 0x9a, 0x9b, 0x20, 0xd4, 0x83, 0x66, 0x40,
-	0x18, 0x13, 0x21, 0x92, 0x21, 0xce, 0xe4, 0xe7, 0xf6, 0x87, 0x04, 0x2b, 0x22, 0xbd, 0x55, 0x49,
-	0xf5, 0x38, 0x84, 0x1e, 0x41, 0x3d, 0x8a, 0x89, 0xeb, 0xb3, 0x85, 0x7a, 0x90, 0x3f, 0x61, 0x4a,
-	0xe8, 0x3f, 0x97, 0xa0, 0x39, 0x33, 0x9b, 0x7c, 0x9a, 0xa3, 0x98, 0x46, 0x94, 0x91, 0x45, 0x5f,
-	0xa8, 0xd0, 0xf3, 0x1d, 0xc9, 0x4b, 0xbe, 0xa3, 0x04, 0x2f, 0xfa, 0x3e, 0xab, 0x92, 0xea, 0x71,
-	0x08, 0xed, 0x43, 0x65, 0x44, 0x13, 0x22, 0x8f, 0x81, 0x1b, 0x61, 0x21, 0x46, 0x8f, 0x01, 0xf8,
-	0xaf, 0xf4, 0xad, 0x2c, 0x98, 0x03, 0x47, 0x72, 0xd3, 0xfb, 0x50, 0x75, 0x69, 0x10, 0xf8, 0x89,
-	0x3c, 0x01, 0x6e, 0x64, 0xa5, 0x1c, 0xed, 0xc1, 0x3f, 0x4e, 0x16, 0x61, 0xc6, 0xec, 0x7c, 0xc1,
-	0xbe, 0x7c, 0x14, 0xd4, 0xac, 0xbf, 0xf2, 0x62, 0x57, 0xd4, 0x64, 0xd0, 0xfa, 0x0e, 0xc0, 0xf4,
-	0xbb, 0x46, 0x9b, 0x00, 0x31, 0x71, 0x07, 0xc4, 0x3d, 0xb1, 0x93, 0xb1, 0xc8, 0xbc, 0x66, 0xd5,
-	0xe5, 0xca, 0xd1, 0xb8, 0x63, 0x7d, 0x9a, 0x68, 0xca, 0xe9, 0x44, 0x53, 0xce, 0x26, 0x9a, 0xf2,
-	0x63, 0xa2, 0x29, 0xef, 0xcf, 0xb5, 0xd2, 0xd9, 0xb9, 0x56, 0xfa, 0x7a, 0xae, 0x95, 0x8e, 0xef,
-	0x7a, 0x7e, 0x32, 0x48, 0x1d, 0xc3, 0xa5, 0x81, 0xd9, 0xc7, 0x6c, 0x10, 0xe1, 0xcc, 0xcc, 0x0f,
-	0x11, 0x7e, 0x97, 0x1f, 0xfb, 0xe6, 0xfc, 0x5f, 0x89, 0x53, 0x15, 0xeb, 0xfb, 0xbf, 0x02, 0x00,
-	0x00, 0xff, 0xff, 0xaa, 0x0f, 0x78, 0xde, 0x65, 0x06, 0x00, 0x00,
+	// 724 bytes of a gzipped FileDescriptorProto
+	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x8c, 0x95, 0x4f, 0x6f, 0xd3, 0x48,
+	0x18, 0xc6, 0xe3, 0xc6, 0xcd, 0x9f, 0x37, 0x4d, 0x13, 0x8d, 0x76, 0xb5, 0xde, 0xee, 0xd6, 0xe9,
+	0xfa, 0xb0, 0xaa, 0x54, 0xc9, 0xae, 0xb6, 0xbb, 0x87, 0x95, 0xf8, 0xa3, 0xa6, 0x41, 0x40, 0x51,
+	0x11, 0x32, 0x15, 0x87, 0x5e, 0xac, 0xb1, 0x33, 0x38, 0x56, 0x63, 0x8f, 0xe5, 0xb1, 0xa3, 0xf8,
+	0x5b, 0x70, 0x42, 0x7c, 0x04, 0xb8, 0x20, 0x3e, 0x46, 0x8f, 0x3d, 0x72, 0x02, 0x94, 0x7e, 0x11,
+	0x34, 0xe3, 0x71, 0x43, 0x52, 0x0a, 0x39, 0xc5, 0x33, 0xef, 0xf3, 0xf3, 0xe3, 0x79, 0xde, 0xd7,
+	0x0e, 0x6c, 0xa7, 0x24, 0x1a, 0x92, 0x24, 0x0c, 0xa2, 0xd4, 0x4a, 0xf3, 0x98, 0x30, 0x2b, 0xc6,
+	0x09, 0x0e, 0x99, 0x19, 0x27, 0x34, 0xa5, 0xa8, 0x3b, 0x2f, 0x9b, 0xa2, 0xbc, 0xf5, 0x8b, 0x4f,
+	0x7d, 0x2a, 0x8a, 0x16, 0xbf, 0x2a, 0x74, 0x5b, 0xba, 0x4f, 0xa9, 0x3f, 0x26, 0x96, 0x58, 0xb9,
+	0xd9, 0x4b, 0x6b, 0x98, 0x25, 0x38, 0x0d, 0x68, 0x54, 0xd4, 0x8d, 0xf7, 0x55, 0xe8, 0x1c, 0xd1,
+	0x88, 0x91, 0x88, 0x65, 0xec, 0x99, 0x70, 0x40, 0x07, 0xb0, 0xee, 0x8e, 0xa9, 0x77, 0xae, 0x29,
+	0x3b, 0xca, 0x6e, 0xeb, 0x9f, 0x6d, 0x73, 0xd9, 0xcb, 0xec, 0xf3, 0x72, 0xa1, 0xb6, 0x0b, 0x2d,
+	0xba, 0x03, 0x0d, 0x32, 0x09, 0x86, 0x24, 0xf2, 0x88, 0xb6, 0x26, 0xb8, 0x9d, 0x9b, 0xdc, 0x03,
+	0xa9, 0x90, 0xe8, 0x35, 0x81, 0xee, 0x43, 0x73, 0x82, 0xc7, 0xc1, 0x10, 0xa7, 0x34, 0xd1, 0xaa,
+	0x02, 0xff, 0xeb, 0x26, 0xfe, 0xa2, 0x94, 0x48, 0x7e, 0xce, 0xa0, 0xff, 0xa1, 0x3e, 0x21, 0x09,
+	0x0b, 0x68, 0xa4, 0xa9, 0x02, 0xef, 0x7d, 0x07, 0x2f, 0x04, 0x12, 0x2e, 0xf5, 0xdc, 0x9b, 0xe5,
+	0x91, 0x37, 0x4a, 0x68, 0x94, 0x6b, 0xeb, 0xb7, 0x79, 0x3f, 0x2f, 0x25, 0xa5, 0xf7, 0x35, 0xc3,
+	0xbd, 0xd3, 0x20, 0x24, 0x34, 0x4b, 0xb5, 0xda, 0x6d, 0xde, 0xa7, 0x85, 0xa0, 0xf4, 0x96, 0x7a,
+	0xb4, 0x0f, 0x2a, 0x76, 0xbd, 0x40, 0xab, 0x0b, 0xee, 0xcf, 0x9b, 0xdc, 0x61, 0xff, 0xe8, 0xb1,
+	0x84, 0x84, 0xd2, 0x38, 0x82, 0xd6, 0x37, 0xe9, 0xa3, 0x3f, 0xa0, 0x19, 0xe2, 0xa9, 0xe3, 0xe6,
+	0x29, 0x61, 0xa2, 0x5f, 0x55, 0xbb, 0x11, 0xe2, 0x69, 0x9f, 0xaf, 0xd1, 0x6f, 0x50, 0xe7, 0x45,
+	0x1f, 0x33, 0xd1, 0x92, 0xaa, 0x5d, 0x0b, 0xf1, 0xf4, 0x21, 0x66, 0xc6, 0x3b, 0x05, 0x36, 0x17,
+	0x7b, 0x81, 0xf6, 0x00, 0x71, 0x2d, 0xf6, 0x89, 0x13, 0x65, 0xa1, 0x23, 0x9a, 0x5a, 0xde, 0xb1,
+	0x13, 0xe2, 0xe9, 0xa1, 0x4f, 0x9e, 0x66, 0xa1, 0xb0, 0x66, 0xe8, 0x04, 0xba, 0xa5, 0xb8, 0x9c,
+	0x27, 0xd9, 0xf4, 0xdf, 0xcd, 0x62, 0xe0, 0xcc, 0x72, 0xe0, 0xcc, 0x81, 0x14, 0xf4, 0x1b, 0x17,
+	0x9f, 0x7a, 0x95, 0x37, 0x9f, 0x7b, 0x8a, 0xbd, 0x59, 0xdc, 0xaf, 0xac, 0x2c, 0x1e, 0xa2, 0xba,
+	0x78, 0x08, 0xe3, 0x3f, 0xe8, 0x2c, 0xf5, 0x1d, 0x19, 0xd0, 0x8e, 0x33, 0xd7, 0x39, 0x27, 0xb9,
+	0x23, 0x52, 0xd2, 0x94, 0x9d, 0xea, 0x6e, 0xd3, 0x6e, 0xc5, 0x99, 0xfb, 0x84, 0xe4, 0xa7, 0x7c,
+	0xcb, 0xd8, 0x87, 0xf6, 0x42, 0xbf, 0x51, 0x0f, 0x5a, 0x38, 0x8e, 0x9d, 0x72, 0x4a, 0xf8, 0xc9,
+	0x54, 0x1b, 0x70, 0x1c, 0x4b, 0x99, 0x71, 0x06, 0x1b, 0x8f, 0x30, 0x1b, 0x91, 0xa1, 0x04, 0xfe,
+	0x86, 0x8e, 0x48, 0xc1, 0x59, 0x0e, 0xb8, 0x2d, 0xb6, 0x4f, 0xca, 0x94, 0x0d, 0x68, 0xcf, 0x75,
+	0xf3, 0xac, 0x5b, 0xa5, 0x8a, 0x07, 0xfe, 0x5a, 0x81, 0xce, 0xd2, 0x04, 0xa1, 0x01, 0xb4, 0x43,
+	0xc2, 0x98, 0x08, 0x91, 0x8c, 0x71, 0x2e, 0x5f, 0xb7, 0x1f, 0x24, 0xa8, 0x8a, 0xf4, 0x36, 0x24,
+	0x35, 0xe0, 0x10, 0xba, 0x0b, 0xcd, 0x38, 0x21, 0x5e, 0xc0, 0x56, 0xea, 0x41, 0x71, 0x87, 0x39,
+	0x61, 0x7c, 0x58, 0x83, 0xf6, 0xc2, 0x6c, 0xf2, 0x69, 0x8e, 0x13, 0x1a, 0x53, 0x46, 0x56, 0x7d,
+	0xa0, 0x52, 0xcf, 0x4f, 0x24, 0x2f, 0xf9, 0x89, 0x52, 0xbc, 0xea, 0xf3, 0x6c, 0x48, 0x6a, 0xc0,
+	0x21, 0x74, 0x00, 0xea, 0x84, 0xa6, 0x44, 0x7e, 0x06, 0x7e, 0x0a, 0x0b, 0x31, 0xba, 0x07, 0xc0,
+	0x7f, 0xa5, 0xaf, 0xba, 0x62, 0x0e, 0x1c, 0x11, 0xa6, 0xc7, 0x6a, 0x63, 0xbd, 0x5b, 0x3b, 0x56,
+	0x1b, 0xb5, 0x6e, 0xdd, 0xae, 0x79, 0x34, 0x0c, 0x83, 0xd4, 0xfe, 0xd5, 0xcd, 0x63, 0xcc, 0x98,
+	0x53, 0x2c, 0x1d, 0xf9, 0xce, 0x1a, 0x7b, 0x00, 0xf3, 0xb7, 0x12, 0x6d, 0x03, 0x24, 0xc4, 0x1b,
+	0x11, 0xef, 0xdc, 0x49, 0xa7, 0x22, 0xb1, 0x86, 0xdd, 0x94, 0x3b, 0xa7, 0xd3, 0xbe, 0xfd, 0x76,
+	0xa6, 0x2b, 0x17, 0x33, 0x5d, 0xb9, 0x9c, 0xe9, 0xca, 0x97, 0x99, 0xae, 0xbc, 0xba, 0xd2, 0x2b,
+	0x97, 0x57, 0x7a, 0xe5, 0xe3, 0x95, 0x5e, 0x39, 0xfb, 0xd7, 0x0f, 0xd2, 0x51, 0xe6, 0x9a, 0x1e,
+	0x0d, 0xad, 0x21, 0x66, 0xa3, 0x18, 0xe7, 0x56, 0xf1, 0x09, 0xe0, 0xab, 0xe2, 0xa3, 0x6d, 0x2d,
+	0xff, 0x11, 0xb8, 0x35, 0xb1, 0x7f, 0xf0, 0x35, 0x00, 0x00, 0xff, 0xff, 0x17, 0x03, 0x59, 0x60,
+	0x23, 0x06, 0x00, 0x00,
 }
 
 func (this *ConsensusParams) Equal(that interface{}) bool {
@@ -958,18 +934,6 @@ func (this *TimeoutParams) Equal(that interface{}) bool {
 	} else if that1.VoteDelta != nil {
 		return false
 	}
-	if this.Commit != nil && that1.Commit != nil {
-		if *this.Commit != *that1.Commit {
-			return false
-		}
-	} else if this.Commit != nil {
-		return false
-	} else if that1.Commit != nil {
-		return false
-	}
-	if this.BypassCommitTimeout != that1.BypassCommitTimeout {
-		return false
-	}
 	return true
 }
 func (this *ABCIParams) Equal(that interface{}) bool {
@@ -1333,64 +1297,44 @@ func (m *TimeoutParams) MarshalToSizedBuffer(dAtA []byte) (int, error) {
 	_ = i
 	var l int
 	_ = l
-	if m.BypassCommitTimeout {
-		i--
-		if m.BypassCommitTimeout {
-			dAtA[i] = 1
-		} else {
-			dAtA[i] = 0
-		}
-		i--
-		dAtA[i] = 0x30
-	}
-	if m.Commit != nil {
-		n11, err11 := github_com_gogo_protobuf_types.StdDurationMarshalTo(*m.Commit, dAtA[i-github_com_gogo_protobuf_types.SizeOfStdDuration(*m.Commit):])
+	if m.VoteDelta != nil {
+		n11, err11 := github_com_gogo_protobuf_types.StdDurationMarshalTo(*m.VoteDelta, dAtA[i-github_com_gogo_protobuf_types.SizeOfStdDuration(*m.VoteDelta):])
 		if err11 != nil {
 			return 0, err11
 		}
 		i -= n11
 		i = encodeVarintParams(dAtA, i, uint64(n11))
 		i--
-		dAtA[i] = 0x2a
+		dAtA[i] = 0x22
 	}
-	if m.VoteDelta != nil {
-		n12, err12 := github_com_gogo_protobuf_types.StdDurationMarshalTo(*m.VoteDelta, dAtA[i-github_com_gogo_protobuf_types.SizeOfStdDuration(*m.VoteDelta):])
+	if m.Vote != nil {
+		n12, err12 := github_com_gogo_protobuf_types.StdDurationMarshalTo(*m.Vote, dAtA[i-github_com_gogo_protobuf_types.SizeOfStdDuration(*m.Vote):])
 		if err12 != nil {
 			return 0, err12
 		}
 		i -= n12
 		i = encodeVarintParams(dAtA, i, uint64(n12))
 		i--
-		dAtA[i] = 0x22
+		dAtA[i] = 0x1a
 	}
-	if m.Vote != nil {
-		n13, err13 := github_com_gogo_protobuf_types.StdDurationMarshalTo(*m.Vote, dAtA[i-github_com_gogo_protobuf_types.SizeOfStdDuration(*m.Vote):])
+	if m.ProposeDelta != nil {
+		n13, err13 := github_com_gogo_protobuf_types.StdDurationMarshalTo(*m.ProposeDelta, dAtA[i-github_com_gogo_protobuf_types.SizeOfStdDuration(*m.ProposeDelta):])
 		if err13 != nil {
 			return 0, err13
 		}
 		i -= n13
 		i = encodeVarintParams(dAtA, i, uint64(n13))
 		i--
-		dAtA[i] = 0x1a
+		dAtA[i] = 0x12
 	}
-	if m.ProposeDelta != nil {
-		n14, err14 := github_com_gogo_protobuf_types.StdDurationMarshalTo(*m.ProposeDelta, dAtA[i-github_com_gogo_protobuf_types.SizeOfStdDuration(*m.ProposeDelta):])
+	if m.Propose != nil {
+		n14, err14 := github_com_gogo_protobuf_types.StdDurationMarshalTo(*m.Propose, dAtA[i-github_com_gogo_protobuf_types.SizeOfStdDuration(*m.Propose):])
 		if err14 != nil {
 			return 0, err14
 		}
 		i -= n14
 		i = encodeVarintParams(dAtA, i, uint64(n14))
 		i--
-		dAtA[i] = 0x12
-	}
-	if m.Propose != nil {
-		n15, err15 := github_com_gogo_protobuf_types.StdDurationMarshalTo(*m.Propose, dAtA[i-github_com_gogo_protobuf_types.SizeOfStdDuration(*m.Propose):])
-		if err15 != nil {
-			return 0, err15
-		}
-		i -= n15
-		i = encodeVarintParams(dAtA, i, uint64(n15))
-		i--
 		dAtA[i] = 0xa
 	}
 	return len(dAtA) - i, nil
@@ -1590,13 +1534,6 @@ func (m *TimeoutParams) Size() (n int) {
 		l = github_com_gogo_protobuf_types.SizeOfStdDuration(*m.VoteDelta)
 		n += 1 + l + sovParams(uint64(l))
 	}
-	if m.Commit != nil {
-		l = github_com_gogo_protobuf_types.SizeOfStdDuration(*m.Commit)
-		n += 1 + l + sovParams(uint64(l))
-	}
-	if m.BypassCommitTimeout {
-		n += 2
-	}
 	return n
 }
 
@@ -2663,62 +2600,6 @@ func (m *TimeoutParams) Unmarshal(dAtA []byte) error {
 				return err
 			}
 			iNdEx = postIndex
-		case 5:
-			if wireType != 2 {
-				return fmt.Errorf("proto: wrong wireType = %d for field Commit", wireType)
-			}
-			var msglen int
-			for shift := uint(0); ; shift += 7 {
-				if shift >= 64 {
-					return ErrIntOverflowParams
-				}
-				if iNdEx >= l {
-					return io.ErrUnexpectedEOF
-				}
-				b := dAtA[iNdEx]
-				iNdEx++
-				msglen |= int(b&0x7F) << shift
-				if b < 0x80 {
-					break
-				}
-			}
-			if msglen < 0 {
-				return ErrInvalidLengthParams
-			}
-			postIndex := iNdEx + msglen
-			if postIndex < 0 {
-				return ErrInvalidLengthParams
-			}
-			if postIndex > l {
-				return io.ErrUnexpectedEOF
-			}
-			if m.Commit == nil {
-				m.Commit = new(time.Duration)
-			}
-			if err := github_com_gogo_protobuf_types.StdDurationUnmarshal(m.Commit, dAtA[iNdEx:postIndex]); err != nil {
-				return err
-			}
-			iNdEx = postIndex
-		case 6:
-			if wireType != 0 {
-				return fmt.Errorf("proto: wrong wireType = %d for field BypassCommitTimeout", wireType)
-			}
-			var v int
-			for shift := uint(0); ; shift += 7 {
-				if shift >= 64 {
-					return ErrIntOverflowParams
-				}
-				if iNdEx >= l {
-					return io.ErrUnexpectedEOF
-				}
-				b := dAtA[iNdEx]
-				iNdEx++
-				v |= int(b&0x7F) << shift
-				if b < 0x80 {
-					break
-				}
-			}
-			m.BypassCommitTimeout = bool(v != 0)
 		default:
 			iNdEx = preIndex
 			skippy, err := skipParams(dAtA[iNdEx:])
diff --git a/proto/tendermint/types/params.proto b/proto/tendermint/types/params.proto
index 302ca71971..5d0ce28cc6 100644
--- a/proto/tendermint/types/params.proto
+++ b/proto/tendermint/types/params.proto
@@ -116,17 +116,9 @@ message TimeoutParams {
   google.protobuf.Duration vote       = 3 [(gogoproto.stdduration) = true];
   google.protobuf.Duration vote_delta = 4 [(gogoproto.stdduration) = true];
 
-  // commit configures how long Tendermint will wait after receiving a quorum of
-  // precommits before beginning consensus for the next height. This can be
-  // used to allow slow precommits to arrive for inclusion in the next height before progressing.
-  google.protobuf.Duration commit = 5 [(gogoproto.stdduration) = true];
-
-  // bypass_commit_timeout configures the node to proceed immediately to
-  // the next height once the node has received all precommits for a block, forgoing
-  // the remaining commit timeout.
-  // Setting bypass_commit_timeout false (the default) causes Tendermint to wait
-  // for the full commit timeout.
-  bool bypass_commit_timeout = 6;
+  // removed fields in 0.14
+  reserved "commit", "bypass_commit_timeout";
+  reserved 5, 6;
 }
 
 // ABCIParams configure functionality specific to the Application Blockchain Interface.
diff --git a/test/e2e/tests/app_test.go b/test/e2e/tests/app_test.go
index 470c523bfe..b14e1ef684 100644
--- a/test/e2e/tests/app_test.go
+++ b/test/e2e/tests/app_test.go
@@ -218,7 +218,7 @@ func TestApp_TxTooBig(t *testing.T) {
 	/// Timeout to read response from single node
 	const readTimeout = 1 * time.Second
 	/// Time to process whole mempool
-	const includeInBlockTimeout = 75 * time.Second
+	const includeInBlockTimeout = 120 * time.Second
 
 	mainCtx, cancel := context.WithCancel(context.Background())
 	defer cancel()
diff --git a/types/params.go b/types/params.go
index 04ceda4693..3242f005fd 100644
--- a/types/params.go
+++ b/types/params.go
@@ -4,6 +4,7 @@ import (
 	"crypto/sha256"
 	"errors"
 	"fmt"
+	"os"
 	"time"
 
 	"github.com/dashpay/tenderdash/crypto/bls12381"
@@ -86,12 +87,15 @@ type SynchronyParams struct {
 
 // TimeoutParams configure the timings of the steps of the Tendermint consensus algorithm.
 type TimeoutParams struct {
-	Propose             time.Duration `json:"propose,string"`
-	ProposeDelta        time.Duration `json:"propose_delta,string"`
-	Vote                time.Duration `json:"vote,string"`
-	VoteDelta           time.Duration `json:"vote_delta,string"`
-	Commit              time.Duration `json:"commit,string"`
-	BypassCommitTimeout bool          `json:"bypass_commit_timeout"`
+	Propose      time.Duration `json:"propose,string"`
+	ProposeDelta time.Duration `json:"propose_delta,string"`
+	Vote         time.Duration `json:"vote,string"`
+	VoteDelta    time.Duration `json:"vote_delta,string"`
+
+	// Unused, TODO: Remove in 0.15
+	Commit time.Duration `json:"commit,string"`
+	// Unused, TODO: Remove in 0.15
+	BypassCommitTimeout bool `json:"bypass_commit_timeout"`
 }
 
 // ABCIParams configure ABCI functionality specific to the Application Blockchain
@@ -172,12 +176,10 @@ func (s SynchronyParams) SynchronyParamsOrDefaults() SynchronyParams {
 
 func DefaultTimeoutParams() TimeoutParams {
 	return TimeoutParams{
-		Propose:             3000 * time.Millisecond,
-		ProposeDelta:        500 * time.Millisecond,
-		Vote:                1000 * time.Millisecond,
-		VoteDelta:           500 * time.Millisecond,
-		Commit:              1000 * time.Millisecond,
-		BypassCommitTimeout: false,
+		Propose:      3000 * time.Millisecond,
+		ProposeDelta: 500 * time.Millisecond,
+		Vote:         1000 * time.Millisecond,
+		VoteDelta:    500 * time.Millisecond,
 	}
 }
 
@@ -207,9 +209,6 @@ func (t TimeoutParams) TimeoutParamsOrDefaults() TimeoutParams {
 	if t.VoteDelta == 0 {
 		t.VoteDelta = defaults.VoteDelta
 	}
-	if t.Commit == 0 {
-		t.Commit = defaults.Commit
-	}
 	return t
 }
 
@@ -227,13 +226,6 @@ func (t TimeoutParams) VoteTimeout(round int32) time.Duration {
 	) * time.Nanosecond
 }
 
-// CommitTime accepts ti, the time at which the consensus engine received +2/3
-// precommits for a block and returns the point in time at which the consensus
-// engine should begin consensus on the next block.
-func (t TimeoutParams) CommitTime(ti time.Time) time.Time {
-	return ti.Add(t.Commit)
-}
-
 func (val *ValidatorParams) IsValidPubkeyType(pubkeyType string) bool {
 	for i := 0; i < len(val.PubKeyTypes); i++ {
 		if val.PubKeyTypes[i] == pubkeyType {
@@ -319,14 +311,19 @@ func (params ConsensusParams) ValidateConsensusParams() error {
 		return fmt.Errorf("timeout.VoteDelta must be greater than 0. Got: %d", params.Timeout.VoteDelta)
 	}
 
-	if params.Timeout.Commit <= 0 {
-		return fmt.Errorf("timeout.Commit must be greater than 0. Got: %d", params.Timeout.Commit)
-	}
-
 	if len(params.Validator.PubKeyTypes) == 0 {
 		return errors.New("len(Validator.PubKeyTypes) must be greater than 0")
 	}
 
+	// TODO: Remove in v0.15
+	if params.Timeout.Commit != 0 {
+		fmt.Fprintln(os.Stderr, "WARNING: ConsensusParams.Timeout.Commit is not used and will be removed in v0.15")
+	}
+	// TODO: Remove in v0.15
+	if params.Timeout.BypassCommitTimeout {
+		fmt.Fprintln(os.Stderr, "WARNING: ConsensusParams.Timeout.BypassCommitTimeout is not used and will be removed in v0.15")
+	}
+
 	// Check if keyType is a known ABCIPubKeyType
 	for i := 0; i < len(params.Validator.PubKeyTypes); i++ {
 		keyType := params.Validator.PubKeyTypes[i]
@@ -418,10 +415,6 @@ func (params ConsensusParams) UpdateConsensusParams(params2 *tmproto.ConsensusPa
 		if params2.Timeout.VoteDelta != nil {
 			res.Timeout.VoteDelta = *params2.Timeout.GetVoteDelta()
 		}
-		if params2.Timeout.Commit != nil {
-			res.Timeout.Commit = *params2.Timeout.GetCommit()
-		}
-		res.Timeout.BypassCommitTimeout = params2.Timeout.GetBypassCommitTimeout()
 	}
 	if params2.Abci != nil {
 		res.ABCI.RecheckTx = params2.Abci.GetRecheckTx()
@@ -451,12 +444,10 @@ func (params *ConsensusParams) ToProto() tmproto.ConsensusParams {
 			Precision:    &params.Synchrony.Precision,
 		},
 		Timeout: &tmproto.TimeoutParams{
-			Propose:             &params.Timeout.Propose,
-			ProposeDelta:        &params.Timeout.ProposeDelta,
-			Vote:                &params.Timeout.Vote,
-			VoteDelta:           &params.Timeout.VoteDelta,
-			Commit:              &params.Timeout.Commit,
-			BypassCommitTimeout: params.Timeout.BypassCommitTimeout,
+			Propose:      &params.Timeout.Propose,
+			ProposeDelta: &params.Timeout.ProposeDelta,
+			Vote:         &params.Timeout.Vote,
+			VoteDelta:    &params.Timeout.VoteDelta,
 		},
 		Abci: &tmproto.ABCIParams{
 			RecheckTx: params.ABCI.RecheckTx,
@@ -503,10 +494,6 @@ func ConsensusParamsFromProto(pbParams tmproto.ConsensusParams) ConsensusParams
 		if pbParams.Timeout.VoteDelta != nil {
 			c.Timeout.VoteDelta = *pbParams.Timeout.GetVoteDelta()
 		}
-		if pbParams.Timeout.Commit != nil {
-			c.Timeout.Commit = *pbParams.Timeout.GetCommit()
-		}
-		c.Timeout.BypassCommitTimeout = pbParams.Timeout.BypassCommitTimeout
 	}
 	if pbParams.Abci != nil {
 		c.ABCI.RecheckTx = pbParams.Abci.GetRecheckTx()
diff --git a/types/params_test.go b/types/params_test.go
index 7e74c21315..a5abcfa6a4 100644
--- a/types/params_test.go
+++ b/types/params_test.go
@@ -173,21 +173,19 @@ func TestConsensusParamsValidation(t *testing.T) {
 }
 
 type makeParamsArgs struct {
-	blockBytes          int64
-	blockGas            int64
-	recheck             bool
-	evidenceAge         int64
-	maxEvidenceBytes    int64
-	pubkeyTypes         []string
-	precision           time.Duration
-	messageDelay        time.Duration
-	bypassCommitTimeout bool
+	blockBytes       int64
+	blockGas         int64
+	recheck          bool
+	evidenceAge      int64
+	maxEvidenceBytes int64
+	pubkeyTypes      []string
+	precision        time.Duration
+	messageDelay     time.Duration
 
 	propose      *time.Duration
 	proposeDelta *time.Duration
 	vote         *time.Duration
 	voteDelta    *time.Duration
-	commit       *time.Duration
 }
 
 func makeParams(args makeParamsArgs) ConsensusParams {
@@ -206,9 +204,7 @@ func makeParams(args makeParamsArgs) ConsensusParams {
 	if args.voteDelta == nil {
 		args.voteDelta = durationPtr(1)
 	}
-	if args.commit == nil {
-		args.commit = durationPtr(1)
-	}
+
 	return ConsensusParams{
 		Block: BlockParams{
 			MaxBytes: args.blockBytes,
@@ -227,12 +223,10 @@ func makeParams(args makeParamsArgs) ConsensusParams {
 			MessageDelay: args.messageDelay,
 		},
 		Timeout: TimeoutParams{
-			Propose:             *args.propose,
-			ProposeDelta:        *args.proposeDelta,
-			Vote:                *args.vote,
-			VoteDelta:           *args.voteDelta,
-			Commit:              *args.commit,
-			BypassCommitTimeout: args.bypassCommitTimeout,
+			Propose:      *args.propose,
+			ProposeDelta: *args.proposeDelta,
+			Vote:         *args.vote,
+			VoteDelta:    *args.voteDelta,
 		},
 		ABCI: ABCIParams{
 			RecheckTx: args.recheck,
@@ -293,30 +287,24 @@ func TestConsensusParamsUpdate(t *testing.T) {
 		{
 			// update timeout params
 			initialParams: makeParams(makeParamsArgs{
-				propose:             durationPtr(3 * time.Second),
-				proposeDelta:        durationPtr(500 * time.Millisecond),
-				vote:                durationPtr(time.Second),
-				voteDelta:           durationPtr(500 * time.Millisecond),
-				commit:              durationPtr(time.Second),
-				bypassCommitTimeout: false,
+				propose:      durationPtr(3 * time.Second),
+				proposeDelta: durationPtr(500 * time.Millisecond),
+				vote:         durationPtr(time.Second),
+				voteDelta:    durationPtr(500 * time.Millisecond),
 			}),
 			updates: &tmproto.ConsensusParams{
 				Timeout: &tmproto.TimeoutParams{
-					Propose:             durationPtr(2 * time.Second),
-					ProposeDelta:        durationPtr(400 * time.Millisecond),
-					Vote:                durationPtr(5 * time.Second),
-					VoteDelta:           durationPtr(400 * time.Millisecond),
-					Commit:              durationPtr(time.Minute),
-					BypassCommitTimeout: true,
+					Propose:      durationPtr(2 * time.Second),
+					ProposeDelta: durationPtr(400 * time.Millisecond),
+					Vote:         durationPtr(5 * time.Second),
+					VoteDelta:    durationPtr(400 * time.Millisecond),
 				},
 			},
 			updatedParams: makeParams(makeParamsArgs{
-				propose:             durationPtr(2 * time.Second),
-				proposeDelta:        durationPtr(400 * time.Millisecond),
-				vote:                durationPtr(5 * time.Second),
-				voteDelta:           durationPtr(400 * time.Millisecond),
-				commit:              durationPtr(time.Minute),
-				bypassCommitTimeout: true,
+				propose:      durationPtr(2 * time.Second),
+				proposeDelta: durationPtr(400 * time.Millisecond),
+				vote:         durationPtr(5 * time.Second),
+				voteDelta:    durationPtr(400 * time.Millisecond),
 			}),
 		},
 		// fine updates
@@ -396,12 +384,10 @@ func TestProto(t *testing.T) {
 		makeParams(makeParamsArgs{precision: time.Second, messageDelay: time.Minute}),
 		makeParams(makeParamsArgs{precision: time.Nanosecond, messageDelay: time.Millisecond}),
 		makeParams(makeParamsArgs{
-			propose:             durationPtr(2 * time.Second),
-			proposeDelta:        durationPtr(400 * time.Millisecond),
-			vote:                durationPtr(5 * time.Second),
-			voteDelta:           durationPtr(400 * time.Millisecond),
-			commit:              durationPtr(time.Minute),
-			bypassCommitTimeout: true,
+			propose:      durationPtr(2 * time.Second),
+			proposeDelta: durationPtr(400 * time.Millisecond),
+			vote:         durationPtr(5 * time.Second),
+			voteDelta:    durationPtr(400 * time.Millisecond),
 		}),
 	}
 
diff --git a/version/version.go b/version/version.go
index eeab252ea8..206bb1716b 100644
--- a/version/version.go
+++ b/version/version.go
@@ -11,7 +11,7 @@ const (
 	// when not using git describe. It is formatted with semantic versioning.
 	TMVersionDefault = "0.14.0-dev.3"
 	// ABCISemVer is the semantic version of the ABCI library
-	ABCISemVer = "0.26.0"
+	ABCISemVer = "0.26.1"
 
 	ABCIVersion = ABCISemVer
 )