Your problem can be solved in $O(\log k)$ time per query by augmenting layered range trees. Let me start with a slower solution first, and then I discuss how the time complexity can be improved.
Consider each segment $[s_i, e_i]$ as a $2$-dimensional point $(s_i, e_i)$ with an associated weight $w_i$. In your case $w_i = e_i - s_i$, but the following solution works in general.
A 2D-range tree consists in a logarithmic-height outer binary-search tree in which each leaf represents the $x$-coordinate of a point, which can be thought of as a trivial interval. Each internal vertex $v$ having $u$ and $z$ as children represents the interval of the $x$-axis going from the left endpoint of $u$'s interval to the right endpoint of $v$'s interval.
A vertex $v$ of the outer tree points to an array $A(v)$ storing exactly the points whose $x$-coordinate lies in $v$'s interval. This array is sorted according to the points' $y$-coordinate.
Let $k$ be the number of points in the range tree. Given an interval $[x_a,x_b]$ of the $x$-axis and an interval $[y_a, y_b]$ of the $y$-axis, we can navigate the outer tree to find a set $V$ of $O(\log k)$ vertices such the union of their intervals covers exactly $[x_a,x_b]$. In your case $x_a = y_a = L$, $x_b = y_B = R$.
For each vertex $v \in V$ we can further binary search the array $A(v)$ to find the range of indices $i_v, j_v$ of $A(v)$ containing the points that simultaneously have their $x$ coordinate in $[x_a,x_b]$ (from the choice of $v$) and their $y$ coordinate in $[y_a, y_b]$ (from the binary search).
Each binary search requires $O(\log k)$ time. Therefore, the total time spent so far is $O(\log^2 k)$.
To find the point with the largest weight, the trivial solution would be to inspect all points $(s_i,e_i)$ in the discovered ranges and return the one maximizing $w_i$, however this would be too costly since there can be many candidates. Instead, we can build a satellite range minimum query (RMQ) oracle $\mathcal{O}(v)$ attached to each $A(v)$. A range minimum query oracle preprocesses an array $B$ and, given two indices $i$ and $j$, is able to report an index $h$ such that $i \le h \le j$ and $B[h]$ is maximized. These oracles can be built in linear time and support constant-time queries. For each $A(v)$ consider the array $B(v)$ such that the $i$-th entry of $B(v)$ is the weight of the $i$-th point in $A(v)$ and then build a RMQ oracle $\mathcal{O}(v)$ on $B(v)$.
You can now query each oracle $\mathcal{O}(v)$ with $v \in V$ using the indices $i_v, j_v$ to find the point with maximum weight. Querying all oracles requires $O(\log k)$ time, and hence the overall time spent is $O(\log^2 k + \log k) = O(\log^2 k)$ per query.
To reduce the query time further, you can use the cross linking idea from fractional cascading. This is a known technique and the resulting data structure is known a layered range tree. Essentially, you are able to simultaneously find the set $V$ and, for each $v \in V$, all the indices $i_v$ and $j_v$ in time $O(\log k)$ (instead of $O(\log^2 k)$). This brings down the overall time needed to answer a query to just $O(\log k)$.
The building time of a layered range tree with two dimensions and $k$ points is $O(k \log k)$, and so is the time needed to build the satellite RMQ oracles (since the overall size of all the arrays is also $O(k \log k)$).
Here is a C++ implementation of a 2D Layered range tree that can be augmented by defining custom node types via dependency injection. The relevant file is TwoDLayeredRangeTree.h and is heavily commented.
In the same repository there is an implementation of a RMQ oracle via jump pointers. The building time of such an oracle is $O(n \log n)$ (more complex oracles having a linear building time exist) and the query time is $O(1)$ as long as std::bit_width runs in constant time (modern processors can report the number of leading 0s in a single instruction).
Finally, there is also an an example program defining a custom range tree node that uses the above RMQ oracle and (essentially) solves the problem mentioned above (more precisely it shows how to find the lightest point in a specified 2D query range).
A compiler supporting C++20 is required.
