input:

ref.1;rack.1;1     #group1
ref.1;rack.1;2     #group1
ref.1;rack.2;1     #group2
ref.2;rack.3;1     #group3
ref.2;rack.3;2     #group3
ref.2;rack.3;3     #group3

ref.1;rack.1;2
ref.1;rack.2;1
ref.2;rack.3;3

BEGIN{FS=OFS=";"}

{array[$1$2] = $0

for(a in array)
if(<$0 is last record>) print array[a]}

To know the last record, you have read the full input stream and then in the END pattern, print out the records. Since you are using an associative array in the mentioned manner, the elements of it will always contain the last records of any group.
And, setting OFS is useless in this case.

BEGIN{FS=";"}
{array[$1,$2]=$0}
END{for(a in array) print array[a]}

Thanks elixir_sinari. I got it now for this way !

And what about if I wanted to keep the highest value in the last field instead of the last line (which is the same here but just for me to know)?

Assuming only positive values in the third field, you may try:

BEGIN{FS=";"}
$3>=highest[$1,$2]{maxrec[$1,$2]=$0;highest[$1,$2]=$3}
END{
for(i in maxrec)
 print maxrec[i]
}

Here are some options for you. This script provides several ways of processing the input file giving different results depending on whether you want the highest value for $3 or the last value for $3, all entries with matching field 1 and field 2 values adjacent or spread throughout the input file, and whether or not you care if the output order is the same as the input file order:

#!/bin/ksh
printf "Following assumes all entries with matching field 1 & field 2 are
adjacent and prints the last entry found.\n"
awk 'BEGIN {FS = OFS = ";"}
last != $1 FS $2 {
        if(last != "") print last, hi3
        last = $1 FS $2
        hi3 = $3
        next
}
        {hi3 = $3}
END {   if(last != "") print last, hi3}' input

printf "\nFollowing assumes all entries with matching field 1 & field 2 are
adjacent and prints the entry with highest value in field 3.\n"
awk 'BEGIN {FS = OFS = ";"}
last != $1 FS $2 {
        if(last != "") print last, hi3
        last = $1 FS $2
        hi3 = $3
        next
}
        {if($3 > hi3) hi3 = $3}
END {   if(last != "") print last, hi3}' input

printf "\nFollowing assumes entries with matching field 1 & field 2 might not be
adjacent and prints the last entry found.  Output order is not guaranteed to
match the order of first appearance in the input file.\n"
awk 'BEGIN {FS = OFS = ";"}
{       k3[$1 FS $2] = $3}
END {   for (k in k3) print k, k3[k]}' input

printf "\nFollowing assumes entries with matching field 1 & field 2 might not be
adjacent and prints the highest entry found.  Output order is not guaranteed to
match the order of first appearance in the input file.\n"
awk 'BEGIN {FS = OFS = ";"}
{       if(kc[$1 FS $2]++ == 0) k3[$1 FS $2] = $3
        else if($3 > k3[$1 FS $2]) k3[$1 FS $2] = $3
}
END {   for (k in kc) print k, k3[k]}' input

printf "\nFollowing assumes entries with matching field 1 & field 2 might not be
adjacent and prints the highest entry found.  Output order is guaranteed to
match the order of first appearance in the input file.\n"
awk 'BEGIN {FS = OFS = ";"}
{       if(kc[$1 FS $2]++ == 0) {
                k3[$1 FS $2] = $3
                order[++cnt] = $1 FS $2
        } else if($3 > k3[$1 FS $2]) k3[$1 FS $2] = $3
}
END {   for(i = 1; i <= cnt; i++) print order[i], k3[order[i]]}' input

split;test;2
ref.1;rack.1;2
ref.1;rack.1;1
ref.1;rack.2;1
split;test;3
ref.2;rack.3;1
ref.2;rack.3;2
ref.2;rack.3;3
split;test;1

Following assumes all entries with matching field 1 & field 2 are
adjacent and prints the last entry found.
split;test;2
ref.1;rack.1;1
ref.1;rack.2;1
split;test;3
ref.2;rack.3;3
split;test;1

Following assumes all entries with matching field 1 & field 2 are
adjacent and prints the entry with highest value in field 3.
split;test;2
ref.1;rack.1;2
ref.1;rack.2;1
split;test;3
ref.2;rack.3;3
split;test;1

Following assumes entries with matching field 1 & field 2 might not be
adjacent and prints the last entry found.  Output order is not guaranteed to
match the order of first appearance in the input file.
split;test;1
ref.2;rack.3;3
ref.1;rack.1;1
ref.1;rack.2;1

Following assumes entries with matching field 1 & field 2 might not be
adjacent and prints the highest entry found.  Output order is not guaranteed to
match the order of first appearance in the input file.
split;test;3
ref.2;rack.3;3
ref.1;rack.1;2
ref.1;rack.2;1

Following assumes entries with matching field 1 & field 2 might not be
adjacent and prints the highest entry found.  Output order is guaranteed to
match the order of first appearance in the input file.
split;test;3
ref.1;rack.1;2
ref.1;rack.2;1
ref.2;rack.3;3

Waoww !!! This is a very complete answer !
Thanks a lot !