diff --git a/testutil/mock/types_mock_appmodule.go b/testutil/mock/types_mock_appmodule.go
index b5cab1121f0e..78820360b3bf 100644
--- a/testutil/mock/types_mock_appmodule.go
+++ b/testutil/mock/types_mock_appmodule.go
@@ -360,3 +360,45 @@ func (mr *MockCoreAppModuleMockRecorder) ValidateGenesis(arg0 interface{}) *gomo
 	mr.mock.ctrl.T.Helper()
 	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ValidateGenesis", reflect.TypeOf((*MockCoreAppModule)(nil).ValidateGenesis), arg0)
 }
+
+// MockCoreModuleWithPreBlock is a mock of CoreModuleWithPreBlock interface.
+type MockCoreModuleWithPreBlock struct {
+	MockCoreAppModule
+	recorder *MockCoreModuleWithPreBlockMockRecorder
+}
+
+// MockCoreModuleWithPreBlockMockRecorder is the mock recorder for MockCoreModuleWithPreBlock.
+type MockCoreModuleWithPreBlockMockRecorder struct {
+	mock *MockCoreModuleWithPreBlock
+}
+
+// NewMockCoreModuleWithPreBlock creates a new mock instance.
+func NewMockCoreModuleWithPreBlock(ctrl *gomock.Controller) *MockCoreModuleWithPreBlock {
+	mock := &MockCoreModuleWithPreBlock{
+		MockCoreAppModule: MockCoreAppModule{
+			ctrl: ctrl,
+		},
+	}
+	mock.recorder = &MockCoreModuleWithPreBlockMockRecorder{mock}
+	return mock
+}
+
+// EXPECT returns an object that allows the caller to indicate expected use.
+func (m *MockCoreModuleWithPreBlock) EXPECT() *MockCoreModuleWithPreBlockMockRecorder {
+	return m.recorder
+}
+
+// PreBlock mocks base method.
+func (m *MockCoreModuleWithPreBlock) PreBlock(arg0 context.Context) (appmodule.ResponsePreBlock, error) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "PreBlock", arg0)
+	ret0, _ := ret[0].(appmodule.ResponsePreBlock)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// PreBlock indicates an expected call of PreBlock.
+func (mr *MockCoreModuleWithPreBlockMockRecorder) PreBlock(arg0 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PreBlock", reflect.TypeOf((*MockCoreModuleWithPreBlock)(nil).PreBlock), arg0)
+}
\ No newline at end of file
diff --git a/types/module/module.go b/types/module/module.go
index 7850c26e0988..d61097113df0 100644
--- a/types/module/module.go
+++ b/types/module/module.go
@@ -283,7 +283,7 @@ type Manager struct {
 func NewManager(modules ...AppModule) *Manager {
 	moduleMap := make(map[string]interface{})
 	modulesStr := make([]string, 0, len(modules))
-	preBeginModulesStr := make([]string, 0, len(modules))
+	preBeginModulesStr := make([]string, 0)
 	for _, module := range modules {
 		moduleMap[module.Name()] = module
 		modulesStr = append(modulesStr, module.Name())
@@ -309,9 +309,13 @@ func NewManager(modules ...AppModule) *Manager {
 func NewManagerFromMap(moduleMap map[string]appmodule.AppModule) *Manager {
 	simpleModuleMap := make(map[string]interface{})
 	modulesStr := make([]string, 0, len(simpleModuleMap))
+	preBeginModulesStr := make([]string, 0)
 	for name, module := range moduleMap {
 		simpleModuleMap[name] = module
 		modulesStr = append(modulesStr, name)
+		if _, ok := module.(appmodule.HasPreBlocker); ok {
+			preBeginModulesStr = append(preBeginModulesStr, name)
+		}
 	}
 
 	// Sort the modules by name. Given that we are using a map above we can't guarantee the order.
@@ -321,6 +325,7 @@ func NewManagerFromMap(moduleMap map[string]appmodule.AppModule) *Manager {
 		Modules:                  simpleModuleMap,
 		OrderInitGenesis:         modulesStr,
 		OrderExportGenesis:       modulesStr,
+		PreBlockers:              preBeginModulesStr,
 		OrderBeginBlockers:       modulesStr,
 		OrderEndBlockers:         modulesStr,
 		OrderPrecommiters:        modulesStr,
diff --git a/types/module/module_test.go b/types/module/module_test.go
index a87a37b28af3..a204a1c4fc2a 100644
--- a/types/module/module_test.go
+++ b/types/module/module_test.go
@@ -467,6 +467,40 @@ func TestCoreAPIManagerOrderSetters(t *testing.T) {
 	require.Equal(t, []string{"module3", "module2", "module1"}, mm.OrderPrecommiters)
 }
 
+func TestCoreAPIManager_PreBlock(t *testing.T) {
+	mockCtrl := gomock.NewController(t)
+	t.Cleanup(mockCtrl.Finish)
+
+	mockAppModule1 := mock.NewMockCoreModuleWithPreBlock(mockCtrl)
+	mm := module.NewManagerFromMap(map[string]appmodule.AppModule{
+		"module1": mockAppModule1,
+		"module2": mock.NewMockCoreAppModule(mockCtrl),
+	})
+	require.NotNil(t, mm)
+	require.Equal(t, 2, len(mm.Modules))
+	require.Equal(t, 1, len(mm.PreBlockers))
+
+	mockAppModule1.EXPECT().PreBlock(gomock.Any()).Times(1).Return(sdk.ResponsePreBlock{
+		ConsensusParamsChanged: true,
+	}, nil)
+	res, err := mm.PreBlock(sdk.Context{})
+	require.NoError(t, err)
+	require.True(t, res.ConsensusParamsChanged)
+
+	// test false
+	mockAppModule1.EXPECT().PreBlock(gomock.Any()).Times(1).Return(sdk.ResponsePreBlock{
+		ConsensusParamsChanged: false,
+	}, nil)
+	res, err = mm.PreBlock(sdk.Context{})
+	require.NoError(t, err)
+	require.False(t, res.ConsensusParamsChanged)
+
+	// test error
+	mockAppModule1.EXPECT().PreBlock(gomock.Any()).Times(1).Return(sdk.ResponsePreBlock{}, errors.New("some error"))
+	_, err = mm.PreBlock(sdk.Context{})
+	require.EqualError(t, err, "some error")
+}
+
 func TestCoreAPIManager_BeginBlock(t *testing.T) {
 	mockCtrl := gomock.NewController(t)
 	t.Cleanup(mockCtrl.Finish)