Before I answer your actual question, let me first show you how to simplify your code a lot.
First, instead of Table[MT[[i, 1]], {i, 1, 5}] you can simply write Table[[All, 1]], which means "take all rows, but only the first column). Obviously you also can do the same with Table[MT[[i, 1]], {i, 1, 5}].
You can also get rid of your third Table by observing that you can also select a list of rows by giving a list of indices. That is, you don't need L1 and L2 at all (unless you need them for your further code, of course), and can simply write
ListPlot[MT[[All, {1, 2}]] ]
Solution using Select
Now to plot only the rows where the third index is 3, the best way is to first generate a list which only contains those lines, and plot that. For this purpose Mathematica provides the function Select, which takes a list and a predicate function, and returns a list of all elements for which this function returns true. Your table is a list of rows, and you want to select rows, therefore you can apply Select directly to the list. This could be done as follows:
(* the predicate function *)
thirdElementIsOne[row_] := (row[[3]] == 1)
(* the sublist *)
selectedRows = Select[MT, thirdElementIsOne];
(* plot the first two columns *)
ListPlot[selectedRows[[All, {1, 2}]] ]
Now it seems quite wasteful to provide a function definition (and waste another symbol) for the second argument of Select. But Mathematica has a solution for this: pure functions (note however that Mathematica's use of the term "pure functions" don't correspond to what elsewhere is meant by that term; in other languages one usually speaks of "unnamed functions" or "lambda functions" for this concept). A pure function can be written in the form Function[argument, expression] (or, for more than one argument, Function[{arguments}, expression]). So the above code could also be written as
(* the sublist *)
selectedRows = Select[MT, Function[row, row[[3]] == 1] ];
(* plot the first two columns *)
ListPlot[selectedRows[[All, {1, 2}]] ]
But given the simplicity of the function, even this syntax seems unnecessarily verbose. Thus Mathematica offers an even terser syntax: If you write any expression followed by an &, it defines a pure function. With this syntax there's of course no way to name arguments (which can be a problem if you have nested pure functions). Instead, you write the first argument as # or #1 (both are equivalent; # is shorter, but #1 is more consistent if you have more arguments), the second one as #2, etc.
In the case above, there is just one argument (the row), therefore you can write
(* the sublist *)
selectedRows = Select[MT, #[[3]] == 1&];
(* plot the first two columns *)
ListPlot[selectedRows[[All, {1, 2}]] ]
Now the expression is so short that it again doesn't seem to make sense to store it in a separate variable (unless you need it again later), therefore let's just insert it in the ListPlot command to get
ListPlot[Select[MT, #[[3]] == 1&][[All, {1, 2}]] ]
Solution using Position
If your table gets large, and there are many rows containing 1 in the third column, you might not want to actually copy all that data. In that case, you might want to first get a list of row indices, and use that to select the data to plot.
To this end, we need the indices of rows where the third column is 1. To Get a list of indices, there's the Mathematica function Position. It takes a list and a pattern, and gives a list of indices for elements matching the pattern.
Now what a pattern is and how they are matched is a topic in itself, however in this case all you have to know is that to match a given specific expression you normally use the expression itself as pattern.
Now the list we need to examine is the third column of ML, which, as described in the beginning, can be obtained as MT[[All, 3]]. The expression we want to select for is 1. Therefore the expression we need is
Position[MT[[All, 3]], 1]
(*
==> {{1}, {2}, {5}}
*)
However as you can see above, this does not return a list of indices, but a list of one-element list of indices. This is because in general, you need several indices to specify a position (e.g. if we had applied it to ML itself, you would need two indices to specify the position of any 1 in it), and thus the elements returned are lists giving all the elements. However, knowing that our list has only one-element sublists, we can use Flatten to get rid of the extra level:
Flatten@Position[MT[[All, 3]], 1]
(*
==> {1, 2, 5}
*)
(The @ syntax I've used here is just another way to apply a function to a single argument, which saves you a keystroke: Flatten@x is exactly equivalent to Flatten[x].)
Now that we have a list of indices, we can just use it as first index to ML:
ListPlot[MT[[Flatten@Position[MT[[All, 3]], 1], {1, 2}]] ]
