diff --git a/src/libslic3r/AABBTreeLines.hpp b/src/libslic3r/AABBTreeLines.hpp
index ae5569b517..990b3197fd 100644
--- a/src/libslic3r/AABBTreeLines.hpp
+++ b/src/libslic3r/AABBTreeLines.hpp
@@ -339,15 +339,15 @@ public:
         return {distance, nearest_line_index_out, nearest_point_out};
     }
 
-    template<bool SIGNED_DISTANCE> Floating distance_from_lines(const Vec<2, typename LineType::Scalar> &point) const
+    template<bool SIGNED_DISTANCE> Floating distance_from_lines(const Vec<2, Scalar> &point) const
     {
         auto [dist, idx, np] = distance_from_lines_extra<SIGNED_DISTANCE>(point);
         return dist;
     }
 
-    std::vector<size_t> all_lines_in_radius(const Vec<2, typename LineType::Scalar> &point, Floating radius)
+    std::vector<size_t> all_lines_in_radius(const Vec<2, Scalar> &point, Floating radius)
     {
-        return AABBTreeLines::all_lines_in_radius(this->lines, this->tree, point, radius * radius);
+        return AABBTreeLines::all_lines_in_radius(this->lines, this->tree, point.template cast<Floating>(), radius * radius);
     }
 
     template<bool sorted> std::vector<std::pair<Vec<2, Scalar>, size_t>> intersections_with_line(const LineType &line) const
diff --git a/src/libslic3r/GCode/ExtrusionProcessor.hpp b/src/libslic3r/GCode/ExtrusionProcessor.hpp
index c802105635..668c89b079 100644
--- a/src/libslic3r/GCode/ExtrusionProcessor.hpp
+++ b/src/libslic3r/GCode/ExtrusionProcessor.hpp
@@ -21,6 +21,7 @@
 #include <iterator>
 #include <limits>
 #include <numeric>
+#include <ostream>
 #include <unordered_map>
 #include <utility>
 #include <vector>
@@ -268,22 +269,22 @@ public:
         std::vector<ProcessedPoint> processed_points;
         processed_points.reserve(extended_points.size());
         for (size_t i = 0; i < extended_points.size(); i++) {
-            ExtendedPoint &curr = extended_points[i];
+            const ExtendedPoint &curr = extended_points[i];
             const ExtendedPoint &next = extended_points[i + 1 < extended_points.size() ? i + 1 : i];
 
-            // We are going to enforce slowdown over curled extrusions by increasing the point distance. The overhang speed is based on
-            // signed distance from the prev layer, where 0 means fully overlapping extrusions and thus no slowdown, while extrusion_width
-            // and more means full overhang, thus full slowdown. However, for curling, we take unsinged distance from the curled lines and
-            // artifically modifiy the distance
+            float artificial_distance_to_curled_lines = 0.0;
             {
-                Vec2d middle = 0.5 * (curr.position + next.position);
-                auto [distance_from_curled, line_idx,
-                      p]     = prev_curled_extrusions[current_object].distance_from_lines_extra<false>(Point::new_scale(middle));
-                if (distance_from_curled < scale_(2.5 * path.width)) {
-                    float artificially_increased_distance = path.width * (1.0 - (unscaled(distance_from_curled) / (2.5 * path.width))) *
-                                                            (prev_curled_extrusions[current_object].get_line(line_idx).curled_height /
-                                                             (path.height * 10.0f)); // max_curled_height_factor from SupportSpotGenerator
-                    curr.distance = std::max(curr.distance, artificially_increased_distance);
+                Vec2d middle       = 0.5 * (curr.position + next.position);
+                auto  line_indices = prev_curled_extrusions[current_object].all_lines_in_radius(Point::new_scale(middle),
+                                                                                                scale_(10.0 * path.width));
+
+                for (size_t idx : line_indices) {
+                    const CurledLine &line                 = prev_curled_extrusions[current_object].get_line(idx);
+                    float             distance_from_curled = unscaled(line_alg::distance_to(line, Point::new_scale(middle)));
+                    float             dist                 = path.width * (1.0 - (distance_from_curled / (10.0 * path.width))) *
+                                 (1.0 - (distance_from_curled / (10.0 * path.width))) *
+                                 (line.curled_height / (path.height * 10.0f)); // max_curled_height_factor from SupportSpotGenerator
+                    artificial_distance_to_curled_lines = std::max(artificial_distance_to_curled_lines, dist);
                 }
             }
 
@@ -301,12 +302,14 @@ public:
                 return (1.0f - t) * lower_dist->second + t * upper_dist->second;
             };
 
-            float extrusion_speed = std::min(interpolate_speed(speed_sections, curr.distance),
-                                             interpolate_speed(speed_sections, next.distance));
-            float fan_speed       = std::min(interpolate_speed(fan_speed_sections, curr.distance),
-                                             interpolate_speed(fan_speed_sections, next.distance));
+            float extrusion_speed   = std::min(interpolate_speed(speed_sections, curr.distance),
+                                               interpolate_speed(speed_sections, next.distance));
+            float curled_base_speed = interpolate_speed(speed_sections, artificial_distance_to_curled_lines);
+            float final_speed       = std::min(curled_base_speed, extrusion_speed);
+            float fan_speed         = std::min(interpolate_speed(fan_speed_sections, curr.distance),
+                                               interpolate_speed(fan_speed_sections, next.distance));
 
-            processed_points.push_back({scaled(curr.position), extrusion_speed, int(fan_speed)});
+            processed_points.push_back({scaled(curr.position), final_speed, int(fan_speed)});
         }
         return processed_points;
     }
diff --git a/src/libslic3r/SupportSpotsGenerator.cpp b/src/libslic3r/SupportSpotsGenerator.cpp
index e9f60dabde..afc213ce70 100644
--- a/src/libslic3r/SupportSpotsGenerator.cpp
+++ b/src/libslic3r/SupportSpotsGenerator.cpp
@@ -212,7 +212,7 @@ float estimate_curled_up_height(
     float distance, float curvature, float layer_height, float flow_width, float prev_line_curled_height, Params params)
 {
     float curled_up_height = 0;
-    if (fabs(distance) < 2.5 * flow_width) {
+    if (fabs(distance) < 3.0 * flow_width) {
         curled_up_height = std::max(prev_line_curled_height - layer_height * 0.75f, 0.0f);
     }