A Schwartzian Transform may do the trick. You need to sort the values, which would be:

... but you need to keep track of the keys as well. You can build a temporary data structure of pairs, or a list of two-element array references, where the first element is the value and the second element is the key:

To get back the keys, you need to map over this list and extract the second element of each pair:

That looks like a lot of useless work, and it would be, except that you can stick as many list-transforming functions in the middle as you want -- including a sort. You can also drop the temporary arrays; they're unnecessary. The result is:

my @keys_sorted_by_value =
    map  { $_->[1] }
    sort { $a->[0] <=> $b->[0] }
    map { $hash{$_}, $_ }
    keys %hash;
[download]

Update: Fixed a typo found by Roy Johnson.

The "key" is to push value/key pairs on to @holder. Consider:

use strict;
use warnings;
use Data::Dumper;

my $counter = 3;

my %hash = (
    a1_2 => 0.556,
    a1_3 => 0.345,
    a2_1 => 0.556,
    a2_3 => 0.125,
    a3_1 => 0.345,
    a3_2 => 0.125,
    );

for my $outer (1 .. $counter) {
    my @holder = ();

    for my $inner (1 .. $counter) {
        next if $outer == $inner;

        my $tracker = "a$outer\_$inner";

        foreach my $key (keys %hash) {
            next unless $key eq $tracker;

            my $value = $hash{$key};
            print "$tracker : $key : $value\n";
            push @holder, [$value, $key];
        }
    }

    my @holder_sorted = sort { $a->[0] <=> $b->[0] } @holder;
    print map {"$_->[1] => $_->[0]\n"} @holder_sorted;
}
[download]

Prints:

a1_2 : a1_2 : 0.556
a1_3 : a1_3 : 0.345
a1_3 => 0.345
a1_2 => 0.556
a2_1 : a2_1 : 0.556
a2_3 : a2_3 : 0.125
a2_3 => 0.125
a2_1 => 0.556
a3_1 : a3_1 : 0.345
a3_2 : a3_2 : 0.125
a3_2 => 0.125
a3_1 => 0.345
[download]

Just hold the keys, not the values.

push @holder, $key;
...
my @holder_sorted = sort { $hash{$a} <=> $hash{$b} } @holder;
print("@hash{@holder_sorted}\n");
[download]

Update: I see that people are suggesting that hold both the key and the value. It's unnecessary to hold the value since you already have a convenient way of looking up the value by key: $hash{$key}. But if you want to hold both, might as well use a hash!

my %holder;
...
$holder{$key} = $value;
...
my @holder_sorted = sort { $holder{$a} <=> $holder{$b} } keys @holder;
print("@holder{@holder_sorted}\n");
[download]

my ( $key, $value ) =
  @{                                   # 5. dereference anonymous hash
+                     
    (
        sort { $a->[1] <=> $b->[1] }   # 3. sort numerically by value
        map { [ $_ => $hash{$_} ] }    # 2. convert to anonymous array
        keys %hash                     # 1. each key
    )[-1]                              # 4. get last (highest value)
  };
[download]

Bio.