Probably you don't want grep, but instead map and a regular expression substitution (see perlretut and perlre):

use strict;
use warnings;

my @call = (
    'A19284 hostname 07/09/07 moredata moredata',
    'A19384 hostname 06/09/07 moredata moredata',
    'A19234 hostname 07/08/07 moredata moredata',
    );
my @callClean = map {$_->[1]}
    sort {$a->[0] cmp $b->[0]}
    map {[(join '', @{[split '/', $_->[0]]}[2, 1, 0]), $_->[1]]}
    map {m|^\w+\s+(.*?(\d+/\d+/\d+).*)|; [$2, $1]} @call;

print "$_\n" for @call;
print "$_\n" for @callClean;
[download]

Prints:

A19284 hostname 05/09/07 moredata moredata
A19384 hostname 06/09/07 moredata moredata
A19234 hostname 08/08/07 moredata moredata
hostname 08/08/07 moredata moredata
hostname 05/09/07 moredata moredata
hostname 06/09/07 moredata moredata
[download]

Update: sort by the dates too.

Instead, loop through your array, removing the column you don't want:

for my $line (@call) {
   # remove A192.*4 and following whitespace from the beginning of eac
+h line
   $line =~ s/^A192.*4\s+//;
}
[download]

Try that:

use strict;
use warnings;

my @call = (
    'A19284 hostname 07/09/07 moredata moredata',
    'A19384 hostname 06/09/07 moredata moredata',
    'A19234 hostname 07/08/07 moredata moredata',
    );
print "$_,$/"  for map {s/^\w+\s//;$_} @call;
[download]

# Each eat of splitLines will hold an array ref
my @splitLines;
foreach my $line (@calls) {
    my @bits = split(/\s+/, $line, 4);

    # Discard the first column
    shift @bits;

    # We want to sort by date, so we'll parse
    # the date column and prefix with a sortable value
    my ($mday, $month, $year) = split(m!/!, $bits[1]);
    $month -= 1;  # mktime wants month from 0
    $year += 100; # mktime wants year from 1900
    my $when = POSIX::mktime(0, 0, 0, $mday, $month, $year);

    unshift @bits, $when;
    push @splitLines, [ @bits ];
}

# Sort by first elt
@splitLines = sort { $a->[0] <=> $b->[0] } @splitLines;

# And puts the lines back together again (discarding
# the leading 'when'.
@calls = map { shift @$_; join(' ', @$_) } @splitLines;
[download]

The following speeds up the sort the others presented, and is probably faster overall for anything but trivial data:

my @sorted = map substr($_, 6),
             sort
             map { local $_ = $_;
                   s/^\S+\s*//;
                   my $ymd = join '',
                             reverse
                             split '/',
                             (split / /)[1];
                   "$ymd$_"
                 }
             @data;
[download]

I know I could have saved some characters on the sort line, but this was more aesthetically pleasing to me.

I don't like how it not only clobbers @data, but relies on it. The grep could be replaced with:

             map { local $_ = $_;
                   s/^A\d+ // ? $_ : ()
                 }
[download]

I like that solution because it points out the most significant lesson: that "*" has a specific meaning the original poster did not want.

The star means "zero or any repeats of the previous item" in a regex context. The specific string one wants to match is "the letter A followed by the numbers 1 then 9 followed by two digits of the 0 through 9 series followed by a 4...".

It's very important to take the time to think about a regex in that plodding way or you get matches you won't want. For example, the rest of the line could match.

I hope I'm not being redundant with my bandwidth. Y'all have a good day.