diff --git a/planning/obstacle_cruise_planner/config/obstacle_cruise_planner.param.yaml b/planning/obstacle_cruise_planner/config/obstacle_cruise_planner.param.yaml
index 2ccd000657948..8d0fa93622f12 100644
--- a/planning/obstacle_cruise_planner/config/obstacle_cruise_planner.param.yaml
+++ b/planning/obstacle_cruise_planner/config/obstacle_cruise_planner.param.yaml
@@ -218,3 +218,15 @@
       lpf_gain_slow_down_vel: 0.99 # low-pass filter gain for slow down velocity
       lpf_gain_lat_dist: 0.999 # low-pass filter gain for lateral distance from obstacle to ego's path
       lpf_gain_dist_to_slow_down: 0.7 # low-pass filter gain for distance to slow down start
+    stop:
+      type_specified_params:
+        labels: # For the listed types, the node try to read the following type specified values
+          - "default"
+          - "unknown"
+        # default: For the default type, which denotes the other types listed above, the following param is defined implicitly, and the other type-specified parameters are not defined.
+          # limit_min_acc: common_param.yaml/limit.min_acc
+        unknown:
+          limit_min_acc: -1.2 # overwrite the deceleration limit, in usually, common_param.yaml/limit.min_acc is referred.
+          sudden_object_acc_threshold: -1.1 # If a stop can be achieved by a deceleration smaller than this value, it is not considered as “sudden stop".
+          sudden_object_dist_threshold: 1000.0 # If a stop distance is longer than this value, it is not considered as “sudden stop".
+          abandon_to_stop: false # If true, the planner gives up to stop when it cannot avoid to run over while maintaining the deceleration limit.
diff --git a/planning/obstacle_cruise_planner/include/obstacle_cruise_planner/common_structs.hpp b/planning/obstacle_cruise_planner/include/obstacle_cruise_planner/common_structs.hpp
index 052e7bb721592..34ae20980d3fd 100644
--- a/planning/obstacle_cruise_planner/include/obstacle_cruise_planner/common_structs.hpp
+++ b/planning/obstacle_cruise_planner/include/obstacle_cruise_planner/common_structs.hpp
@@ -113,14 +113,15 @@ struct StopObstacle : public TargetObstacleInterface
 {
   StopObstacle(
     const std::string & arg_uuid, const rclcpp::Time & arg_stamp,
-    const geometry_msgs::msg::Pose & arg_pose, const Shape & arg_shape,
-    const double arg_lon_velocity, const double arg_lat_velocity,
+    const ObjectClassification & object_classification, const geometry_msgs::msg::Pose & arg_pose,
+    const Shape & arg_shape, const double arg_lon_velocity, const double arg_lat_velocity,
     const geometry_msgs::msg::Point arg_collision_point,
     const double arg_dist_to_collide_on_decimated_traj)
   : TargetObstacleInterface(arg_uuid, arg_stamp, arg_pose, arg_lon_velocity, arg_lat_velocity),
     shape(arg_shape),
     collision_point(arg_collision_point),
-    dist_to_collide_on_decimated_traj(arg_dist_to_collide_on_decimated_traj)
+    dist_to_collide_on_decimated_traj(arg_dist_to_collide_on_decimated_traj),
+    classification(object_classification)
   {
   }
   Shape shape;
@@ -129,6 +130,7 @@ struct StopObstacle : public TargetObstacleInterface
                       // calculateMarginFromObstacleOnCurve() and  should be removed as it can be
                       // replaced by ”dist_to_collide_on_decimated_traj”
   double dist_to_collide_on_decimated_traj;
+  ObjectClassification classification;
 };
 
 struct CruiseObstacle : public TargetObstacleInterface
diff --git a/planning/obstacle_cruise_planner/include/obstacle_cruise_planner/node.hpp b/planning/obstacle_cruise_planner/include/obstacle_cruise_planner/node.hpp
index fd65446408db1..3aea741e3b2f4 100644
--- a/planning/obstacle_cruise_planner/include/obstacle_cruise_planner/node.hpp
+++ b/planning/obstacle_cruise_planner/include/obstacle_cruise_planner/node.hpp
@@ -272,8 +272,7 @@ class ObstacleCruisePlannerNode : public rclcpp::Node
   bool is_driving_forward_{true};
   bool enable_slow_down_planning_{false};
 
-  // previous closest obstacle
-  std::shared_ptr<StopObstacle> prev_closest_stop_obstacle_ptr_{nullptr};
+  std::vector<StopObstacle> prev_closest_stop_obstacles_{};
 
   std::unique_ptr<tier4_autoware_utils::LoggerLevelConfigure> logger_configure_;
 
diff --git a/planning/obstacle_cruise_planner/include/obstacle_cruise_planner/planner_interface.hpp b/planning/obstacle_cruise_planner/include/obstacle_cruise_planner/planner_interface.hpp
index 416c36b116059..72610e1219d58 100644
--- a/planning/obstacle_cruise_planner/include/obstacle_cruise_planner/planner_interface.hpp
+++ b/planning/obstacle_cruise_planner/include/obstacle_cruise_planner/planner_interface.hpp
@@ -23,6 +23,7 @@
 #include "tier4_autoware_utils/ros/update_param.hpp"
 #include "tier4_autoware_utils/system/stop_watch.hpp"
 
+#include <limits>
 #include <memory>
 #include <optional>
 #include <string>
@@ -42,7 +43,8 @@ class PlannerInterface
     vehicle_info_(vehicle_info),
     ego_nearest_param_(ego_nearest_param),
     debug_data_ptr_(debug_data_ptr),
-    slow_down_param_(SlowDownParam(node))
+    slow_down_param_(SlowDownParam(node)),
+    stop_param_(StopParam(node, longitudinal_info))
   {
     stop_reasons_pub_ = node.create_publisher<StopReasonArray>("~/output/stop_reasons", 1);
     velocity_factors_pub_ =
@@ -91,6 +93,7 @@ class PlannerInterface
     updateCommonParam(parameters);
     updateCruiseParam(parameters);
     slow_down_param_.onParam(parameters);
+    stop_param_.onParam(parameters, longitudinal_info_);
   }
 
   Float32MultiArrayStamped getStopPlanningDebugMessage(const rclcpp::Time & current_time) const
@@ -333,6 +336,84 @@ class PlannerInterface
     double lpf_gain_dist_to_slow_down;
   };
   SlowDownParam slow_down_param_;
+  struct StopParam
+  {
+    struct ObstacleSpecificParams
+    {
+      double limit_min_acc;
+      double sudden_object_acc_threshold;
+      double sudden_object_dist_threshold;
+      bool abandon_to_stop;
+    };
+    const std::unordered_map<uint8_t, std::string> types_maps = {
+      {ObjectClassification::UNKNOWN, "unknown"}, {ObjectClassification::CAR, "car"},
+      {ObjectClassification::TRUCK, "truck"},     {ObjectClassification::BUS, "bus"},
+      {ObjectClassification::TRAILER, "trailer"}, {ObjectClassification::MOTORCYCLE, "motorcycle"},
+      {ObjectClassification::BICYCLE, "bicycle"}, {ObjectClassification::PEDESTRIAN, "pedestrian"}};
+    std::unordered_map<std::string, ObstacleSpecificParams> type_specified_param_list;
+    explicit StopParam(rclcpp::Node & node, const LongitudinalInfo & longitudinal_info)
+    {
+      const std::string param_prefix = "stop.type_specified_params.";
+      std::vector<std::string> obstacle_labels{"default"};
+      obstacle_labels =
+        node.declare_parameter<std::vector<std::string>>(param_prefix + "labels", obstacle_labels);
+
+      for (const auto & type_str : obstacle_labels) {
+        if (type_str != "default") {
+          ObstacleSpecificParams param{
+            node.declare_parameter<double>(param_prefix + type_str + ".limit_min_acc"),
+            node.declare_parameter<double>(
+              param_prefix + type_str + ".sudden_object_acc_threshold"),
+            node.declare_parameter<double>(
+              param_prefix + type_str + ".sudden_object_dist_threshold"),
+            node.declare_parameter<bool>(param_prefix + type_str + ".abandon_to_stop")};
+
+          param.sudden_object_acc_threshold =
+            std::min(param.sudden_object_acc_threshold, longitudinal_info.limit_min_accel);
+          param.limit_min_acc = std::min(param.limit_min_acc, param.sudden_object_acc_threshold);
+
+          type_specified_param_list.emplace(type_str, param);
+        }
+      }
+    }
+    void onParam(
+      const std::vector<rclcpp::Parameter> & parameters, const LongitudinalInfo & longitudinal_info)
+    {
+      const std::string param_prefix = "stop.type_specified_params.";
+      for (auto & [type_str, param] : type_specified_param_list) {
+        if (type_str == "default") {
+          continue;
+        }
+        tier4_autoware_utils::updateParam<double>(
+          parameters, param_prefix + type_str + ".limit_min_acc", param.limit_min_acc);
+        tier4_autoware_utils::updateParam<double>(
+          parameters, param_prefix + type_str + ".sudden_object_acc_threshold",
+          param.sudden_object_acc_threshold);
+        tier4_autoware_utils::updateParam<double>(
+          parameters, param_prefix + type_str + ".sudden_object_dist_threshold",
+          param.sudden_object_dist_threshold);
+        tier4_autoware_utils::updateParam<bool>(
+          parameters, param_prefix + type_str + ".abandon_to_stop", param.abandon_to_stop);
+
+        param.sudden_object_acc_threshold =
+          std::min(param.sudden_object_acc_threshold, longitudinal_info.limit_min_accel);
+        param.limit_min_acc = std::min(param.limit_min_acc, param.sudden_object_acc_threshold);
+      }
+    }
+    std::string getParamType(const ObjectClassification label)
+    {
+      const auto type_str = types_maps.at(label.label);
+      if (type_specified_param_list.count(type_str) == 0) {
+        return "default";
+      }
+      return type_str;
+    }
+    ObstacleSpecificParams getParam(const ObjectClassification label)
+    {
+      return type_specified_param_list.at(getParamType(label));
+    }
+  };
+  StopParam stop_param_;
   double moving_object_speed_threshold;
   double moving_object_hysteresis_range;
   std::vector<SlowDownOutput> prev_slow_down_output_;
diff --git a/planning/obstacle_cruise_planner/include/obstacle_cruise_planner/utils.hpp b/planning/obstacle_cruise_planner/include/obstacle_cruise_planner/utils.hpp
index 3b4ab577c2988..48bab514cbf77 100644
--- a/planning/obstacle_cruise_planner/include/obstacle_cruise_planner/utils.hpp
+++ b/planning/obstacle_cruise_planner/include/obstacle_cruise_planner/utils.hpp
@@ -36,8 +36,7 @@ PoseWithStamp getCurrentObjectPose(
   const PredictedObject & predicted_object, const rclcpp::Time & obj_base_time,
   const rclcpp::Time & current_time, const bool use_prediction);
 
-std::optional<StopObstacle> getClosestStopObstacle(
-  const std::vector<StopObstacle> & stop_obstacles);
+std::vector<StopObstacle> getClosestStopObstacles(const std::vector<StopObstacle> & stop_obstacles);
 
 template <class T>
 size_t getIndexWithLongitudinalOffset(
diff --git a/planning/obstacle_cruise_planner/src/node.cpp b/planning/obstacle_cruise_planner/src/node.cpp
index c5f0c73a13b78..41ae29b7d470f 100644
--- a/planning/obstacle_cruise_planner/src/node.cpp
+++ b/planning/obstacle_cruise_planner/src/node.cpp
@@ -1253,9 +1253,9 @@ std::optional<StopObstacle> ObstacleCruisePlannerNode::createStopObstacle(
   }
 
   const auto [tangent_vel, normal_vel] = projectObstacleVelocityToTrajectory(traj_points, obstacle);
-  return StopObstacle{
-    obstacle.uuid, obstacle.stamp, obstacle.pose,          obstacle.shape,
-    tangent_vel,   normal_vel,     collision_point->first, collision_point->second};
+  return StopObstacle{obstacle.uuid, obstacle.stamp,         obstacle.classification,
+                      obstacle.pose, obstacle.shape,         tangent_vel,
+                      normal_vel,    collision_point->first, collision_point->second};
 }
 
 std::optional<SlowDownObstacle> ObstacleCruisePlannerNode::createSlowDownObstacle(
@@ -1386,50 +1386,36 @@ void ObstacleCruisePlannerNode::checkConsistency(
   const rclcpp::Time & current_time, const PredictedObjects & predicted_objects,
   std::vector<StopObstacle> & stop_obstacles)
 {
-  const auto current_closest_stop_obstacle =
-    obstacle_cruise_utils::getClosestStopObstacle(stop_obstacles);
-
-  if (!prev_closest_stop_obstacle_ptr_) {
-    if (current_closest_stop_obstacle) {
-      prev_closest_stop_obstacle_ptr_ =
-        std::make_shared<StopObstacle>(*current_closest_stop_obstacle);
+  for (const auto & prev_closest_stop_obstacle : prev_closest_stop_obstacles_) {
+    const auto predicted_object_itr = std::find_if(
+      predicted_objects.objects.begin(), predicted_objects.objects.end(),
+      [&prev_closest_stop_obstacle](const PredictedObject & po) {
+        return tier4_autoware_utils::toHexString(po.object_id) == prev_closest_stop_obstacle.uuid;
+      });
+    // If previous closest obstacle disappear from the perception result, do nothing anymore.
+    if (predicted_object_itr == predicted_objects.objects.end()) {
+      continue;
     }
-    return;
-  }
 
-  const auto predicted_object_itr = std::find_if(
-    predicted_objects.objects.begin(), predicted_objects.objects.end(),
-    [&](PredictedObject predicted_object) {
-      return tier4_autoware_utils::toHexString(predicted_object.object_id) ==
-             prev_closest_stop_obstacle_ptr_->uuid;
-    });
-  // If previous closest obstacle disappear from the perception result, do nothing anymore.
-  if (predicted_object_itr == predicted_objects.objects.end()) {
-    return;
-  }
-
-  const auto is_disappeared_from_stop_obstacle = std::none_of(
-    stop_obstacles.begin(), stop_obstacles.end(),
-    [&](const auto & obstacle) { return obstacle.uuid == prev_closest_stop_obstacle_ptr_->uuid; });
-  if (is_disappeared_from_stop_obstacle) {
-    // re-evaluate as a stop candidate, and overwrite the current decision if "maintain stop"
-    // condition is satisfied
-    const double elapsed_time = (current_time - prev_closest_stop_obstacle_ptr_->stamp).seconds();
-    if (
-      predicted_object_itr->kinematics.initial_twist_with_covariance.twist.linear.x <
-        behavior_determination_param_.obstacle_velocity_threshold_from_stop_to_cruise &&
-      elapsed_time < behavior_determination_param_.stop_obstacle_hold_time_threshold) {
-      stop_obstacles.push_back(*prev_closest_stop_obstacle_ptr_);
-      return;
+    const auto is_disappeared_from_stop_obstacle = std::none_of(
+      stop_obstacles.begin(), stop_obstacles.end(),
+      [&prev_closest_stop_obstacle](const StopObstacle & so) {
+        return so.uuid == prev_closest_stop_obstacle.uuid;
+      });
+    if (is_disappeared_from_stop_obstacle) {
+      // re-evaluate as a stop candidate, and overwrite the current decision if "maintain stop"
+      // condition is satisfied
+      const double elapsed_time = (current_time - prev_closest_stop_obstacle.stamp).seconds();
+      if (
+        predicted_object_itr->kinematics.initial_twist_with_covariance.twist.linear.x <
+          behavior_determination_param_.obstacle_velocity_threshold_from_stop_to_cruise &&
+        elapsed_time < behavior_determination_param_.stop_obstacle_hold_time_threshold) {
+        stop_obstacles.push_back(prev_closest_stop_obstacle);
+      }
     }
   }
 
-  if (current_closest_stop_obstacle) {
-    prev_closest_stop_obstacle_ptr_ =
-      std::make_shared<StopObstacle>(*current_closest_stop_obstacle);
-  } else {
-    prev_closest_stop_obstacle_ptr_ = nullptr;
-  }
+  prev_closest_stop_obstacles_ = obstacle_cruise_utils::getClosestStopObstacles(stop_obstacles);
 }
 
 bool ObstacleCruisePlannerNode::isObstacleCrossing(
diff --git a/planning/obstacle_cruise_planner/src/planner_interface.cpp b/planning/obstacle_cruise_planner/src/planner_interface.cpp
index f7ce218cf3ccf..6e1de97378d16 100644
--- a/planning/obstacle_cruise_planner/src/planner_interface.cpp
+++ b/planning/obstacle_cruise_planner/src/planner_interface.cpp
@@ -259,129 +259,171 @@ std::vector<TrajectoryPoint> PlannerInterface::generateStopTrajectory(
     rclcpp::get_logger("ObstacleCruisePlanner::PIDBasedPlanner"), enable_debug_info_,
     "stop planning");
 
-  // Get Closest Stop Obstacle
-  const auto closest_stop_obstacle = obstacle_cruise_utils::getClosestStopObstacle(stop_obstacles);
-  if (!closest_stop_obstacle) {
-    // delete marker
-    const auto markers =
-      motion_utils::createDeletedStopVirtualWallMarker(planner_data.current_time, 0);
-    tier4_autoware_utils::appendMarkerArray(markers, &debug_data_ptr_->stop_wall_marker);
-
-    prev_stop_distance_info_ = std::nullopt;
-    return planner_data.traj_points;
-  }
-
-  const auto ego_segment_idx =
-    ego_nearest_param_.findSegmentIndex(planner_data.traj_points, planner_data.ego_pose);
-  const double dist_to_collide_on_ref_traj =
-    motion_utils::calcSignedArcLength(planner_data.traj_points, 0, ego_segment_idx) +
-    closest_stop_obstacle->dist_to_collide_on_decimated_traj;
-
-  const double margin_from_obstacle_considering_behavior_module = [&]() {
-    const double margin_from_obstacle =
-      calculateMarginFromObstacleOnCurve(planner_data, *closest_stop_obstacle);
-    // Use terminal margin (terminal_safe_distance_margin) for obstacle stop
-    const auto ref_traj_length = motion_utils::calcSignedArcLength(
-      planner_data.traj_points, 0, planner_data.traj_points.size() - 1);
-    if (dist_to_collide_on_ref_traj > ref_traj_length) {
-      return longitudinal_info_.terminal_safe_distance_margin;
-    }
-
-    // If behavior stop point is ahead of the closest_obstacle_stop point within a certain margin
-    // we set closest_obstacle_stop_distance to closest_behavior_stop_distance
-    const auto closest_behavior_stop_idx =
-      motion_utils::searchZeroVelocityIndex(planner_data.traj_points, ego_segment_idx + 1);
-    if (closest_behavior_stop_idx) {
-      const double closest_behavior_stop_dist_on_ref_traj =
-        motion_utils::calcSignedArcLength(planner_data.traj_points, 0, *closest_behavior_stop_idx);
-      const double stop_dist_diff = closest_behavior_stop_dist_on_ref_traj -
-                                    (dist_to_collide_on_ref_traj - margin_from_obstacle);
-      if (0.0 < stop_dist_diff && stop_dist_diff < margin_from_obstacle) {
-        return min_behavior_stop_margin_;
+  std::optional<StopObstacle> determined_stop_obstacle{};
+  std::optional<double> determined_zero_vel_dist{};
+  std::optional<double> determined_desired_margin{};
+
+  const auto closest_stop_obstacles =
+    obstacle_cruise_utils::getClosestStopObstacles(stop_obstacles);
+  for (const auto & stop_obstacle : closest_stop_obstacles) {
+    const auto ego_segment_idx =
+      ego_nearest_param_.findSegmentIndex(planner_data.traj_points, planner_data.ego_pose);
+    const double dist_to_collide_on_ref_traj =
+      motion_utils::calcSignedArcLength(planner_data.traj_points, 0, ego_segment_idx) +
+      stop_obstacle.dist_to_collide_on_decimated_traj;
+
+    const double desired_margin = [&]() {
+      const double margin_from_obstacle =
+        calculateMarginFromObstacleOnCurve(planner_data, stop_obstacle);
+      // Use terminal margin (terminal_safe_distance_margin) for obstacle stop
+      const auto ref_traj_length = motion_utils::calcSignedArcLength(
+        planner_data.traj_points, 0, planner_data.traj_points.size() - 1);
+      if (dist_to_collide_on_ref_traj > ref_traj_length) {
+        return longitudinal_info_.terminal_safe_distance_margin;
       }
-    }
-    return margin_from_obstacle;
-  }();
 
-  // Generate Output Trajectory
-  const auto [zero_vel_dist, will_collide_with_obstacle] = [&]() {
-    double candidate_zero_vel_dist =
-      std::max(0.0, dist_to_collide_on_ref_traj - margin_from_obstacle_considering_behavior_module);
+      // If behavior stop point is ahead of the closest_obstacle_stop point within a certain
+      // margin we set closest_obstacle_stop_distance to closest_behavior_stop_distance
+      const auto closest_behavior_stop_idx =
+        motion_utils::searchZeroVelocityIndex(planner_data.traj_points, ego_segment_idx + 1);
+      if (closest_behavior_stop_idx) {
+        const double closest_behavior_stop_dist_on_ref_traj = motion_utils::calcSignedArcLength(
+          planner_data.traj_points, 0, *closest_behavior_stop_idx);
+        const double stop_dist_diff = closest_behavior_stop_dist_on_ref_traj -
+                                      (dist_to_collide_on_ref_traj - margin_from_obstacle);
+        if (0.0 < stop_dist_diff && stop_dist_diff < margin_from_obstacle) {
+          return min_behavior_stop_margin_;
+        }
+      }
+      return margin_from_obstacle;
+    }();
 
-    // Check feasibility to stop
+    // calc stop point against the obstacle
+    double candidate_zero_vel_dist = std::max(0.0, dist_to_collide_on_ref_traj - desired_margin);
     if (suppress_sudden_obstacle_stop_) {
-      // Calculate feasible stop margin (Check the feasibility)
-      const double feasible_stop_dist =
-        calcMinimumDistanceToStop(
-          planner_data.ego_vel, longitudinal_info_.limit_max_accel,
-          longitudinal_info_.limit_min_accel) +
-        motion_utils::calcSignedArcLength(
-          planner_data.traj_points, 0, planner_data.ego_pose.position);
+      const auto acceptable_stop_acc = [&]() -> std::optional<double> {
+        if (stop_param_.getParamType(stop_obstacle.classification) == "default") {
+          return longitudinal_info_.limit_min_accel;
+        }
+        const double distance_to_judge_suddenness = std::min(
+          calcMinimumDistanceToStop(
+            planner_data.ego_vel, longitudinal_info_.limit_max_accel,
+            stop_param_.getParam(stop_obstacle.classification).sudden_object_acc_threshold),
+          stop_param_.getParam(stop_obstacle.classification).sudden_object_dist_threshold);
+        if (candidate_zero_vel_dist > distance_to_judge_suddenness) {
+          return longitudinal_info_.limit_min_accel;
+        }
+        if (stop_param_.getParam(stop_obstacle.classification).abandon_to_stop) {
+          RCLCPP_WARN(
+            rclcpp::get_logger("ObstacleCruisePlanner::StopPlanner"),
+            "[Cruise] abandon to stop against %s object",
+            stop_param_.types_maps.at(stop_obstacle.classification.label).c_str());
+          return std::nullopt;
+        } else {
+          return stop_param_.getParam(stop_obstacle.classification).limit_min_acc;
+        }
+      }();
+      if (!acceptable_stop_acc) {
+        continue;
+      }
 
-      if (candidate_zero_vel_dist < feasible_stop_dist) {
-        candidate_zero_vel_dist = feasible_stop_dist;
-        return std::make_pair(candidate_zero_vel_dist, true);
+      const double acceptable_stop_pos =
+        motion_utils::calcSignedArcLength(
+          planner_data.traj_points, 0, planner_data.ego_pose.position) +
+        calcMinimumDistanceToStop(
+          planner_data.ego_vel, longitudinal_info_.limit_max_accel, acceptable_stop_acc.value());
+      if (acceptable_stop_pos > candidate_zero_vel_dist) {
+        candidate_zero_vel_dist = acceptable_stop_pos;
       }
     }
 
-    // Hold previous stop distance if necessary
-    if (
-      std::abs(planner_data.ego_vel) < longitudinal_info_.hold_stop_velocity_threshold &&
-      prev_stop_distance_info_) {
-      // NOTE: We assume that the current trajectory's front point is ahead of the previous
-      // trajectory's front point.
-      const size_t traj_front_point_prev_seg_idx =
-        motion_utils::findFirstNearestSegmentIndexWithSoftConstraints(
-          prev_stop_distance_info_->first, planner_data.traj_points.front().pose);
-      const double diff_dist_front_points = motion_utils::calcSignedArcLength(
-        prev_stop_distance_info_->first, 0, planner_data.traj_points.front().pose.position,
-        traj_front_point_prev_seg_idx);
-
-      const double prev_zero_vel_dist = prev_stop_distance_info_->second - diff_dist_front_points;
+    if (determined_stop_obstacle) {
+      const bool is_same_param_types =
+        (stop_obstacle.classification.label == determined_stop_obstacle->classification.label);
       if (
-        std::abs(prev_zero_vel_dist - candidate_zero_vel_dist) <
-        longitudinal_info_.hold_stop_distance_threshold) {
-        candidate_zero_vel_dist = prev_zero_vel_dist;
+        (is_same_param_types && stop_obstacle.dist_to_collide_on_decimated_traj >
+                                  determined_stop_obstacle->dist_to_collide_on_decimated_traj) ||
+        (!is_same_param_types && candidate_zero_vel_dist > determined_zero_vel_dist)) {
+        continue;
       }
     }
-    return std::make_pair(candidate_zero_vel_dist, false);
-  }();
+    determined_zero_vel_dist = candidate_zero_vel_dist;
+    determined_stop_obstacle = stop_obstacle;
+    determined_desired_margin = desired_margin;
+  }
+
+  if (!determined_zero_vel_dist) {
+    // delete marker
+    const auto markers =
+      motion_utils::createDeletedStopVirtualWallMarker(planner_data.current_time, 0);
+    tier4_autoware_utils::appendMarkerArray(markers, &debug_data_ptr_->stop_wall_marker);
+
+    prev_stop_distance_info_ = std::nullopt;
+    return planner_data.traj_points;
+  }
+
+  // Hold previous stop distance if necessary
+  if (
+    std::abs(planner_data.ego_vel) < longitudinal_info_.hold_stop_velocity_threshold &&
+    prev_stop_distance_info_) {
+    // NOTE: We assume that the current trajectory's front point is ahead of the previous
+    // trajectory's front point.
+    const size_t traj_front_point_prev_seg_idx =
+      motion_utils::findFirstNearestSegmentIndexWithSoftConstraints(
+        prev_stop_distance_info_->first, planner_data.traj_points.front().pose);
+    const double diff_dist_front_points = motion_utils::calcSignedArcLength(
+      prev_stop_distance_info_->first, 0, planner_data.traj_points.front().pose.position,
+      traj_front_point_prev_seg_idx);
+
+    const double prev_zero_vel_dist = prev_stop_distance_info_->second - diff_dist_front_points;
+    if (
+      std::abs(prev_zero_vel_dist - determined_zero_vel_dist.value()) <
+      longitudinal_info_.hold_stop_distance_threshold) {
+      determined_zero_vel_dist.value() = prev_zero_vel_dist;
+    }
+  }
 
   // Insert stop point
   auto output_traj_points = planner_data.traj_points;
-  const auto zero_vel_idx = motion_utils::insertStopPoint(0, zero_vel_dist, output_traj_points);
+  const auto zero_vel_idx =
+    motion_utils::insertStopPoint(0, *determined_zero_vel_dist, output_traj_points);
   if (zero_vel_idx) {
     // virtual wall marker for stop obstacle
     const auto markers = motion_utils::createStopVirtualWallMarker(
       output_traj_points.at(*zero_vel_idx).pose, "obstacle stop", planner_data.current_time, 0,
       abs_ego_offset, "", planner_data.is_driving_forward);
     tier4_autoware_utils::appendMarkerArray(markers, &debug_data_ptr_->stop_wall_marker);
-    debug_data_ptr_->obstacles_to_stop.push_back(*closest_stop_obstacle);
+    debug_data_ptr_->obstacles_to_stop.push_back(*determined_stop_obstacle);
 
     // Publish Stop Reason
     const auto stop_pose = output_traj_points.at(*zero_vel_idx).pose;
     const auto stop_reasons_msg =
-      makeStopReasonArray(planner_data, stop_pose, *closest_stop_obstacle);
+      makeStopReasonArray(planner_data, stop_pose, *determined_stop_obstacle);
     stop_reasons_pub_->publish(stop_reasons_msg);
     velocity_factors_pub_->publish(makeVelocityFactorArray(planner_data.current_time, stop_pose));
 
-    // Publish if ego vehicle collides with the obstacle with a limit acceleration
+    // Publish if ego vehicle will over run against the stop point with a limit acceleration
+
+    const bool will_over_run = determined_zero_vel_dist.value() >
+                               motion_utils::calcSignedArcLength(
+                                 planner_data.traj_points, 0, planner_data.ego_pose.position) +
+                                 determined_stop_obstacle->dist_to_collide_on_decimated_traj +
+                                 determined_desired_margin.value() + 0.1;
     const auto stop_speed_exceeded_msg =
-      createStopSpeedExceededMsg(planner_data.current_time, will_collide_with_obstacle);
+      createStopSpeedExceededMsg(planner_data.current_time, will_over_run);
     stop_speed_exceeded_pub_->publish(stop_speed_exceeded_msg);
 
-    prev_stop_distance_info_ = std::make_pair(output_traj_points, zero_vel_dist);
+    prev_stop_distance_info_ = std::make_pair(output_traj_points, determined_zero_vel_dist.value());
   }
 
   stop_planning_debug_info_.set(
     StopPlanningDebugInfo::TYPE::STOP_CURRENT_OBSTACLE_DISTANCE,
-    closest_stop_obstacle->dist_to_collide_on_decimated_traj);
+    determined_stop_obstacle->dist_to_collide_on_decimated_traj);
   stop_planning_debug_info_.set(
-    StopPlanningDebugInfo::TYPE::STOP_CURRENT_OBSTACLE_VELOCITY, closest_stop_obstacle->velocity);
-
+    StopPlanningDebugInfo::TYPE::STOP_CURRENT_OBSTACLE_VELOCITY,
+    determined_stop_obstacle->velocity);
   stop_planning_debug_info_.set(
-    StopPlanningDebugInfo::TYPE::STOP_TARGET_OBSTACLE_DISTANCE,
-    margin_from_obstacle_considering_behavior_module);
+    StopPlanningDebugInfo::TYPE::STOP_TARGET_OBSTACLE_DISTANCE, determined_desired_margin.value());
   stop_planning_debug_info_.set(StopPlanningDebugInfo::TYPE::STOP_TARGET_VELOCITY, 0.0);
   stop_planning_debug_info_.set(StopPlanningDebugInfo::TYPE::STOP_TARGET_ACCELERATION, 0.0);
 
diff --git a/planning/obstacle_cruise_planner/src/utils.cpp b/planning/obstacle_cruise_planner/src/utils.cpp
index 6b32ccafc7f42..6c1b3999e40c1 100644
--- a/planning/obstacle_cruise_planner/src/utils.cpp
+++ b/planning/obstacle_cruise_planner/src/utils.cpp
@@ -95,16 +95,21 @@ PoseWithStamp getCurrentObjectPose(
   return PoseWithStamp{obj_base_time, *interpolated_pose};
 }
 
-std::optional<StopObstacle> getClosestStopObstacle(const std::vector<StopObstacle> & stop_obstacles)
+std::vector<StopObstacle> getClosestStopObstacles(const std::vector<StopObstacle> & stop_obstacles)
 {
-  std::optional<StopObstacle> candidate_obstacle = std::nullopt;
+  std::vector<StopObstacle> candidates{};
   for (const auto & stop_obstacle : stop_obstacles) {
-    if (
-      !candidate_obstacle || stop_obstacle.dist_to_collide_on_decimated_traj <
-                               candidate_obstacle->dist_to_collide_on_decimated_traj) {
-      candidate_obstacle = stop_obstacle;
+    const auto itr =
+      std::find_if(candidates.begin(), candidates.end(), [&stop_obstacle](const StopObstacle & co) {
+        return co.classification.label == stop_obstacle.classification.label;
+      });
+    if (itr == candidates.end()) {
+      candidates.emplace_back(stop_obstacle);
+    } else if (
+      stop_obstacle.dist_to_collide_on_decimated_traj < itr->dist_to_collide_on_decimated_traj) {
+      *itr = stop_obstacle;
     }
   }
-  return candidate_obstacle;
+  return candidates;
 }
 }  // namespace obstacle_cruise_utils