Having layer between IPv6 and the physical layer do hop-by-hop fragmentation is permitted by the standard. And in fact if the MTU of the physical layer is smaller than 1280 bytes, such hop-by-hop fragmentation is even mandatory. The exact workings of such a fragmentation below the IPv6 layer is outside of the scope of the IPv6 standard. The exact wording in RFC 2460 is this:
On any link that cannot convey a 1280-octet
packet in one piece, link-specific fragmentation and reassembly must
be provided at a layer below IPv6.
The fragmentation you have in mind is the end-to-end fragmentation in IPv6. And that kind of fragmentation can only be performed by the node originating the packet in the first place. No intermediate router is allowed to perform this kind of fragmentation on a packet which they are forwarding.
As far as I can tell from your question, neither kind of fragmentation is happening in your case.
If you were able to send a 2KB packet from the HTTP client to the router in the first place, that would imply that your LAN was configured to use jumboframes. Another possibility is that the HTTP client is running on a host with support for TCP segmentation offloading. If that was the case, the first packet may appear to be 2KB when observed with tcpdump on the sending host, but on the wire it might actually be one packet with the first 1500 bytes and another packet with the rest.
The 1500 bytes would still be too large for the MTU on the ADSL link. What the actual size of the packet triggering the too big error message was can be seen on the client machine by inspecting the error message with an appropriate tool like for example Wireshark.
What happens once the client's TCP stack receives the too big error depends on which TCP stack is being used. Some will retransmit the same TCP segment using IPv6 fragmentation, others will split the TCP segment into two smaller TCP segments. The IPv6 standard says this:
In order to send a packet larger than a path's MTU, a node may use
the IPv6 Fragment header to fragment the packet at the source and
have it reassembled at the destination(s). However, the use of such
fragmentation is discouraged in any application that is able to
adjust its packets to fit the measured path MTU (i.e., down to 1280
I read this as recommending that the TCP segment is retransmitted as two smaller segments rather than using IPv6 fragmentation. There are multiple reasons for TCP segmentation being preferred over fragmentation.
The router may rate limit the too big error messages. So if you send multiple TCP segments each of which are larger than 2KB, you might only receive an error message for the first. The TCP stack should be able to deal with this by using the smaller MTU once it retransmits the packets which exceeded the MTU the first time around.
What you are seeing might simply be a rate limit which is lower than you were expecting. You can try to measure what rate limit is actually being used and then only take further action if you find it to be unreasonably low.