
<p class="has-drop-cap wp-block-paragraph">S<strong>an Moteur</strong> (e. Panne de Moteur) vann 2023. <strong>Önas Prince</strong> (e. Chocolatier) 2024. <strong>Borups Victory</strong> (e. Googoo Gaagaa) gör debut i loppet i år efter att ha utsetts till Årets Häst förra året. I en högklassig upplaga av Paralympiatravet på Åby är det en stark svensk trio i förgrunden i kampen om 1,5 miljoner kronor i förstapris.</p>



<figure class="wp-block-image size-sulky-mellan2"><img src="https://sulkysport.se/wp-content/uploads/2023/05/sanmoteurbgm230506adamstromstalltz-617x394.jpg" alt="" class="wp-image-440996"/><figcaption class="wp-element-caption">San Moteur och Björn Goop. Foto: Adam Ström/stalltz.se</figcaption></figure>



<p class="wp-block-paragraph">San Moteur har flest frågetecken kring sig. Prix d’Amérique i vintras blev en besvikelse när hästen var alldeles för het och inte klarade startmomentet den stora dagen. Återkomsten i Paralympiauttagningen på Romme ändade med galopp 500 meter från mål.<br>När Björn Goops travare segrade för två år sedan följde han upp med att sluta tvåa i Elitloppet tre veckor senare och då hade han också en brokig väg till finalen på Åby. Hästen tvingades nämligen strykas för feber från den tilltänkta starten på Jägersro två veckor före Paralympiatravet.</p>



<p class="wp-block-paragraph">Önas Prince kom tillbaka förra våren efter långt skadeuppehåll och mjukade upp med två raka segrar i mars-april innan han vann finalen på den näst bästa segertiden i historien, 1.10,1a/2.140 meter. Bara Ringostarr Treb har travat snabbare med 1.10,0. Seger i ett trekilometerslopp och andraplatsen från dödens bakom A Fair Day (e. Maharajah) är uppladdningen i år.<br>– Hade jag fått köra om senaste loppet hade jag laddat från start. Då hade vi tagit ledningen, A Fair Day hade fått gå utvändigt och vi hade vunnit loppet. Den här gången planerar jag att trycka gasen i botten och ladda mot ledningen och sedan släpper jag inte till någon, säger Per Nordström till Kanal75.</p>



<figure class="wp-block-image size-sulky-mellan2"><img src="https://sulkysport.se/wp-content/uploads/2025/04/borupsvictoryelinapaavola-617x333.jpg" alt="" class="wp-image-708682"/><figcaption class="wp-element-caption">Borups Victory och Daniel Wäjersten vinner före Massimo Hoist i Seinäjoki Race. Foto Elina Paavola</figcaption></figure>



<p class="wp-block-paragraph">Daniel Wäjersten vänder tillbaka till västkusten när Borups Victory testar i Paralympiatravet för första gången. Han fick visserligen nöja sig med tredjeplatsen i uttagningen bakom Castor the Star och Kentucky River i årsdebuten i Bollnäs, men följde upp med imponerade Grupp I-seger i finska Seinäjoki Race under påskhelgen.<br>Förra året blev det tre triumfer i Grupp I-lopp och dessutom andraplatsen i Elitloppet för fjolårets bästa äldre travare i Sverige.</p>



<h2 class="wp-block-heading">Startlista Paralympiatravets final</h2>



<p class="wp-block-paragraph">2.140 meter autostart, Åby lördag:<br><strong>Pris: </strong>1.500.000-700.000-325.000-150.000-75.000-40.000-30.000-25.000 kr<br><em>Häst (far) – Kusk (tränare)</em></p>



<ol class="wp-block-list">
<li>Borups Victory (e. Googoo Gaagaa) – Daniel Wäjersten</li>



<li>Önas Prince (e. Chocolatier) – Per Nordström</li>



<li>Kentucky River (e. Father Patrick) – Örjan Kihlström (Daniel Redén)</li>



<li>San Moteur (e. Panne de Moteur) – Björn Goop</li>



<li>A Fair Day (e. Maharajah) – Oscar Ginman (Elisabeth Almheden)</li>



<li>Inmarosa (e. Amiral Sacha) – Leo Abrivard (Laurent Claude Abrivard)</li>



<li>Castor the Star (e. Maharajah) – Mats E Djuse (Jörgen Westholm)</li>



<li>Ture L.A. (e. Maharajah) – Carl Johan Jepson (Maria Törnqvist)</li>



<li>Gaspar d’Angis (e. Quaro) – Louis Baudouin (Jean Michel Baudouin)</li>



<li>Working Class Hero (e. Village Mystic) – Mathieu Mottier (Jörgen Westholm)</li>
</ol>



<p class="has-text-align-center wp-block-paragraph">***</p>



<figure class="wp-block-image size-sulky-mellan2"><img src="https://sulkysport.se/wp-content/uploads/2021/05/pershingolympiatravet-617x333.jpg" alt="" class="wp-image-159998"/><figcaption class="wp-element-caption">Ingemar Stenmark och Linda Haglund flankerar vinnarna Pershing och Berndt Lindstedt i första upplagan av Olympiatravet. Foto Stefan Melander/Stalltz.se</figcaption></figure>



<p class="has-drop-cap wp-block-paragraph">Kärt barn har många namn och lördagens storlopp på Åby, Paralympiatravet, har haft flera under åren. Vid premiären 1979 var namnet Guldmedaljen och loppet var placerat utanför V65-kupongen.</p>



<p class="wp-block-paragraph">Även året efter var det Guldmedaljen som gällde innan det – efter att ha varit inställt 1981 – var premiär för Olympiatravet 1982. 2020 blev det nya namnet Paralympiatravet, sedan det skrivits avtal med Sveriges Paralympiska Kommitté och Parasport.</p>



<p class="wp-block-paragraph">Efter premiäråret på Jägersro var Solvalla arrangör 1980 och 1984 (fyraåringslopp det året) och Åby 1982. Sedan 1985 har Olympiatravet/Paralympiatravet varit bosatt på Åby. Två gånger har Olympiatravet ställts in, 1981 och 1983.</p>



<p class="wp-block-paragraph">1985 började Olympiatravet ta fart när det gällde prispengar. Från 75.000 till 300.000 kronor i förstapris. Torbjörn Jansson triumferade bakom svensk travsports nya superstar <strong>Meadow Road</strong>. Samma år vann han också Elitloppet och båda avdelningarna i Statue of Liberty Trot.</p>



<p class="has-text-align-center wp-block-paragraph">***</p>



<p class="has-drop-cap wp-block-paragraph">Amatörtränade hästar kryllar det inte av i landets storlopp, men i Olympiatravet och Paralympiatravet har det firats framgångar genom åren. Herbert Wallin från dalsländska Bengtsfors tränade duktiga stoet <strong>Jana Bloc</strong> (e. Train Bloc), som tillsammans med Ove R Andersson segrade 1982. Pirjo Vaukonen var kvinnan bakom <strong>Etain Royal</strong> (e. Ulf d’Ombree) vid triumfen med Jorma Kontio 2001.<br>Norrmannen Fredrik Solberg är senast i raden då hans ögonsten <strong>B.B.S.Sugarlight</strong> (e. Super Light) triumferade tillsammans med Peter Untersteiner 2015.</p>



<figure class="wp-block-image size-sulky-mellan2"><img src="https://sulkysport.se/wp-content/uploads/2023/11/elisabethalmheden1-617x333.jpg" alt="" class="wp-image-523531"/><figcaption class="wp-element-caption">Elisabeth Almheden. Foto Mathias Hedlund/Sulkysport</figcaption></figure>



<p class="wp-block-paragraph">I år vänds amatörernas blickar mot Kalmars stolthet <strong>A Fair Day</strong> (e. Maharajah), tränad av Elisabeth Almheden och körd av Oscar Ginman. <br>Förra året tog han en Elitloppsbiljett efter den imponerande årsdebuten i prins Carl Philips Jubileumspokal på Färjestad på långfredagen på 1.09,4a/1.640 meter, men i Elitloppet blev det galopp. Största segern ifjol kom i Müllers på Jägersro på senhösten.</p>



<p class="wp-block-paragraph">I år har A Fair Day varit prickfri i två raka segrar, där han i uttagningen till Paralympiatravet såg helfin ut vid enkel vinst från ledningen på starka 1.10,3a/2.140 meter.</p>



<p class="has-text-align-center wp-block-paragraph">***</p>



<figure class="wp-block-image size-sulky-mellan2"><img src="https://sulkysport.se/wp-content/uploads/2024/05/onasprincedefpara-617x333.jpeg" alt="" class="wp-image-580805"/><figcaption class="wp-element-caption">Önas Prince och Per Nordström segerdefilerar efter Paralympiatravet 2024. Foto: Adam Ström/stalltz.se</figcaption></figure>



<p class="has-drop-cap wp-block-paragraph">Förstapriset var 1,5 miljoner kronor åren 2008 till 2019, men 2020 sänktes det till miljonen jämnt i spåren av coronapandemin. Sedan 2021 är den stora prischecken återställd och den summan kvitterade <strong>Önas Prince</strong> (e. Chocolatier) ut förra året.</p>



<p class="wp-block-paragraph">Önas Prince är som titelförsvarare med i årets upplaga och kan skriva in sig i ett celebert sällskap. Queen L, Copiad och Gidde Palema är nämligen ensamma om att försvara titeln i Olympia- och Paralympiatravet.</p>



<p class="has-text-align-center wp-block-paragraph">***</p>



<p class="has-drop-cap wp-block-paragraph">Daniel Redén har en tränarseger i loppet, då norske <strong>Lionel</strong> (e. Look de Star) segrade 2017. Nu mönstrar han för andra året i rad <strong>Kentucky River</strong> (e. Father Patrick), som slutade tvåa bakom Önas Prince förra året och tog karriärens största prischeck: 700.000 kronor. Ha. var även tvåa i Oslo Grand Prix ifjol över medeldistans.</p>



<figure class="wp-block-image size-sulky-mellan2"><img src="https://sulkysport.se/wp-content/uploads/2025/04/danielreden-617x333.jpg" alt="" class="wp-image-705606"/><figcaption class="wp-element-caption">Daniel Redén. Foto Mathias Hedlund/Sulkysport</figcaption></figure>



<p class="wp-block-paragraph">I vinter testades han i tre starter på Vincennes och efter hemkomsten har han slutat tvåa och etta i uttagningslopp till Paralympiatravet efter starka avslutningar.<br>– Han fick perfekt spår, äntligen, han brukar ju få dåliga spår. Jag hoppas att han hamnar bra till för han har ju en jäkla spurt. Det blir spännande, men jag känner att det är ännu en bra prestation på gång. Han kommer att gå som han gjort på sistone, säger Daniel Redén på Stall Zets hemsida.</p>



<p class="has-text-align-center wp-block-paragraph">***</p>



<p class="has-drop-cap wp-block-paragraph">Andra raka starten i finalen blir det också för Jörgen Westholms bereste <strong>Castor the Star</strong> (e. Maharajah). Från hösten 2023 till hösten 2024 tävlade Castor the Star i Sverige, Finland, Frankrike och USA. Efter utflykter till VM-loppet i New Work i september har han hållit sig på svensk mark och finalbiljetten togs via seger från ledningen i försöket i Bollnäs i årsdebuten efter fem månaders tävlingsuppehåll.</p>



<figure class="wp-block-image size-sulky-mellan2"><img src="https://sulkysport.se/wp-content/uploads/2025/02/00265809055scoopdyga-617x411.jpg" alt="" class="wp-image-684698"/><figcaption class="wp-element-caption">Working Class Hero startar i Paralympiatravet med sin ordinarie kusk. Foto: Scoopdyga</figcaption></figure>



<p class="wp-block-paragraph">Jörgen Westholm står bakom två av finalisterna. Efter ett mycket framgångsrikt vintermeeting på Vincennes vänder <strong>Working Class Hero</strong> (e. Village Mystic) tillbaka till Sverige. Working Class Hero vann Prix Jean-René Gougeon (€90.000), Prix de Bourigny (€71.000) och Prix de Reims (€80.000) och en andraplats i Prix Tenor de Baune (€240.000). I det sista loppet på Vincennes – Prix Jean Cabrol – blev det ”bara” en sjätteplats från rygg ledaren.<br>– Working Class Hero fick upp höger hov i en konkurrents sulkyhjul och tvekade. Efter loppet hade han 76 i vilopuls och Mottier sade också att det fanns krafter sparade. Han känns jättefin i jobben och det ska bli spännande att vara med i Paralympiatravet och se hur mycket han utvecklats av att starta på Vincennes, säger Jörgen Westholm till Sulkysport.</p>



<p class="wp-block-paragraph">Båda hästarna körs av sina ordinarie kuskar på senare tid, Mats E Djuse kör Castor the Star och fransmannen Mathieu Mottier sitter upp bakom Working Class Hero. </p>



<p class="has-text-align-center wp-block-paragraph">***</p>



<p class="has-drop-cap wp-block-paragraph">Paralympiatravet är det riktiga startskottet för storloppssäsongen för den äldre eliten i Sverige och om drygt tre veckor stundar Elitloppet på Solvalla. Att vinna Åbys storlopp och sedan fortsätta med att plocka hem Elitloppet några veckor senare har åtta hästar lyckats med.</p>



<ul class="wp-block-list">
<li>1979 – Pershing (e. Nevele Pride) – Berndt Lindstedt</li>



<li>1985 – Meadow Road (e. Madison Avenue) – Torbjörn Jansson</li>



<li>1995 – Copiad (e. Texas) – Erik Berglöf</li>



<li>2002 – Varenne (e. Waikiki Beach) – Giampaolo Minnucci (Jori Turja)</li>



<li>2004 – Gidde Palema (e. Alf Palema) – Åke Svanstedt</li>



<li>2011 – Brioni (e. Timberland) – Joakim Lövgren</li>



<li>2012 – Commander Crowe (e. Juliano Star) – Christophe Martens (Fabrice Souloy)</li>



<li>2018 – Ringostarr Treb (e. Classic Photo) – Wim Paal (Jerry Riordan)</li>
</ul>



<p class="has-text-align-center wp-block-paragraph">***</p>



<figure class="wp-block-image size-sulky-mellan2"><img src="https://sulkysport.se/wp-content/uploads/2024/04/inmarosa-617x333.jpeg" alt="" class="wp-image-573383"/><figcaption class="wp-element-caption">Inmarosa vinner Prix Vindex på Vincennes den 3 mars 2022 och det är hennes senaste seger. Foto: Gerard Forni</figcaption></figure>



<p class="has-drop-cap wp-block-paragraph">5ston har vunnit Olympiatravet. Först ut var <strong>Jana Bloc</strong> 1982 och hon har följts av <strong>Grades Singing</strong> 1987, <strong>Queen L.</strong> 1993 och 1994 och sedan dröjde det till <strong>Your Highness</strong> 2016. 2021 sällade sig fransyskan <strong>Delia du Pommereux</strong> (e. Niky) till den skaran.</p>



<p class="wp-block-paragraph">Årets hopp på stosidan kommer precis som Delia du Pommereux från Frankrike. <strong>Inmarosa </strong>(e. Amiral Sacha) har inte fått sätta den berömda pricken över i:et i något storlopp, men har varit tvåa i Criterium des 4 ans, Criterium des 5 ans, Prix de France, Prix de Paris och delade andraplatsen i Prix de Belgique förra året med Go On Boy.</p>



<p class="wp-block-paragraph">Inmarosa var oplacerad i genrepet Prix Kerjacques (€120.000) för en knapp månad sedan, men då tävlade hon med skor.<br>– Hon var bra i sitt senaste lopp och tävlade med skor. Målet är att hon ska vara i toppform till Paralympiatravet. Jag tror att hon kommer att trivas på Åby, sade tränaren Laurent-Claude Abrivard till Paris-Turf.</p>



<p class="has-text-align-center wp-block-paragraph">***</p>



<figure class="wp-block-image size-sulky-mellan2"><img src="https://sulkysport.se/wp-content/uploads/2025/04/turel.a.cjjgk-617x333.jpg" alt="" class="wp-image-712053"/><figcaption class="wp-element-caption">Maria Törnqvist-tränade Ture L.A. kvalade in till Paralympiatravets final via seger tillsammans med Carl Johan Jepson. Foto Gunilla König/Stalltz.se</figcaption></figure>



<p class="has-drop-cap wp-block-paragraph">2av tio finalister tränas av kvinnor. Förutom Elisabeth Almhedens A Fair Day handlar det om Maria Törnqvists formstarke valack <strong>Ture L.A.</strong> (e. Maharajah), som ordnade biljetten på egen hand när han vann Sista Chansen i Örebro förra helgen.</p>



<p class="wp-block-paragraph">Ture L.A. kom till Maria Törnqvists stall förra sommaren och har gjort sju starter i nya regin. Fyra av dem har slutat med seger och förutom Sista chansen till Paralympiatravet har han vunnit två försök och en final i silverdivisionen. På priskontot inför nästa lördags stora final finns 2.224.529 kronor, minst av alla deltagare.</p>



<p class="has-text-align-center wp-block-paragraph">***</p>



<figure class="wp-block-image size-sulky-mellan2"><img src="https://sulkysport.se/wp-content/uploads/2024/10/00260744021scoopdyga-617x411.jpg" alt="" class="wp-image-654539"/><figcaption class="wp-element-caption">Gaspar d&#8217;Angis och Eric Raffin. Foto: Scoopdyga</figcaption></figure>



<p class="has-drop-cap wp-block-paragraph">Jean-Michel Baudouins nioårige valack <strong>Gaspar d’Angis</strong> (e. Quaro-Reveuse d’Angis), är det andra franska hoppet i Paralympiatravet. I vinter har han slutat tvåa bakom <strong>Inexess Bleu</strong> (e. Vittel de Brevol) två gånger på Vincennes, i Prix du Bois de Vincennes (€90.000) och i Prix de Luxembourg (€100.000).</p>



<p class="wp-block-paragraph">Ifjol vann Gaspar d’Angis Grand Prix du Centre Est (€100.000) i Lyon, Prix de la Manche (€90.000) på Enghien och Prix des Cevennes (€90.000) på Vincennes.</p>



<p class="wp-block-paragraph">Året innan tog han hem sex försök plus final i Grand National du Trot (€150.000). Gaspar d’Angis är undan <strong>Reveuse d’Angis</strong> (e. Korean), 1.18,7/€840, och har förutom Gaspar d’Angis lämnat <strong>Boucaniere </strong>(e. Rieussec), 1.14,9/€82.890.</p>



<p class="wp-block-paragraph">Franskfödda hästar har faktiskt bara vunnit loppet två gånger: Etain Royal 2001 och Delia du Pommereux 2021.</p>



<p class="has-text-align-center wp-block-paragraph">***</p>



<p class="has-drop-cap wp-block-paragraph">2 avelshingstar har fyra vinnare vardera i Olympiatravet/Paralympiatravet. Texas var först till fyra med Grades Singing 1987, Karate Chop 1991 och Copiad 1995, 1996.<br>Alf Palema fördelade sina fyra vinster på två avkommor; Gidde Palema 2003, 2004, 2005 och Torvald Palema 2008.</p>



<p class="wp-block-paragraph">Tre vinnare i Olympiatravet har Viking Kronos: Thai Tanic 2006, Triton Sund 2009 och Maharajah 2013.<br>Trion Crowntron, Super Play och Waikiki Beach står med två vinnare vardera: Queen L. (1993, 1994), Scandal Play (1997, 1999) och Varenne (2000, 2002).</p>



<p class="has-text-align-center wp-block-paragraph">***</p>



<figure class="wp-block-image size-sulky-mellan2"><img src="https://sulkysport.se/wp-content/uploads/2024/07/castorthestarmal-617x333.jpg" alt="" class="wp-image-616236"/><figcaption class="wp-element-caption">Castor the Star och Mats E Djuse. Foto Mathias Hedlund/Sulkysport</figcaption></figure>



<p class="has-drop-cap wp-block-paragraph"><strong>Maharajah</strong> (e. Viking Kronos) och sonen <strong>Who’s Who</strong> är historiska. Det är första gången en far och son stått som vinnare i storloppet. Pappa Maharajah gjorde när han vann Olympiatravet 2013 på 1.11,0a/2.140 meter tillsammans med Örjan Kihlström och Who’s Who följde upp 2022 – med gemensam ägare, uppfödare och kusk dessutom: Travkompaniet, Menhammar Stuteri och Örjan Kihlström.<br>Maharajah har tre chanser att få ytterligare en vinnare i årets upplaga, där han är pappa till <strong>A Fair Day, Castor the Star</strong> och <strong>Ture L.A.</strong></p>



<p class="wp-block-paragraph">Av avelshingstarna bakom årets finalister har även Chocolatier och Panne de Moteur lämnat en vinnare av Paralympiatravet.</p>



<p class="wp-block-paragraph"><em>Avelshingst (finalist 2025) – Tidigare finalister – Resultat</em></p>



<ul class="wp-block-list">
<li><strong>Chocolatier</strong> (1) – 5 – El Mago Pellini (0) 2015, <strong>Your Highness</strong> (1) 2016, Your Highness (2) 2017, Extreme (2) 2017, Önas Prince (1) 2024</li>



<li><strong>Father Patrick</strong> (1) – 1 – Kentucky River (2) 2024</li>



<li><strong>Googoo Gaagaa</strong> (1) – 1 – Usain Töll (0) 2024</li>



<li><strong>Maharajah</strong> (3) – 4 – Who’s Who (6) 2021, <strong>Who’s Who</strong> (1) 2022, Bengurion Jet (4) 2024, Castor the Star (6) 2024</li>



<li><strong>Panne de Moteur</strong> (1) – 1 – <strong>San Moteur</strong> (1) 2023</li>



<li><strong>Amiral Sacha</strong> (1), <strong>Quaro</strong> (1) och <strong>Village Mystic</strong> (1) har inte haft startande avkommor tidigare.</li>
</ul>



<p class="has-text-align-center wp-block-paragraph">***</p>



<figure class="wp-block-image size-sulky-mellan2"><img src="https://sulkysport.se/wp-content/uploads/2024/05/sugarcanehanoverolympia-617x333.jpg" alt="" class="wp-image-589679"/><figcaption class="wp-element-caption">Sugarcane Hanover och Gunnar Eggen vid utklassningssegern i Olympiatravet 1988. Foto Stefan Melander/Stalltz.se</figcaption></figure>



<p class="has-drop-cap wp-block-paragraph">S<strong>ugarcane Hanovers</strong> triumf 1988 är fortfarande för många det största ögonblicket i loppets historia när han vann i överlägsen stil för Gunnar Eggen och utklassade världsmästaren Callit. Sugarcane Hanover värmde dåligt, men gjorde sina motståndare till statister när det blev allvar.</p>



<p class="wp-block-paragraph">Han svepte runt sina konkurrenter till spets redan innan sista kurvan och vann på 1.14,4a/2.140 meter, medan Callit noterade 1.15,6 som tvåa – akterseglad med ”många längder.”</p>



<p class="wp-block-paragraph">Gunnar Eggen är inte ensam norrman att ha vunnit. Göran Antonsen satt upp bakom ögonstenen Lionel (e. Look de Star) – i träning hos Daniel Redén – och blåste runt alla konkurrenter till seger 2017.</p>



<p class="wp-block-paragraph">I år saknas norsk deltagare.</p>



<p class="has-text-align-center wp-block-paragraph">***</p>



<p class="wp-block-paragraph"><strong>Här är hästskötarna bakom de tio finalisterna i Paralympiatravet:</strong></p>



<ul class="wp-block-list">
<li>Borups Victory – Moa Bylund</li>



<li>Önas Prince – Emma Nordström</li>



<li>Kentucky River – Ellinor Wennebring</li>



<li>San Moteur – Jessica Jonsson</li>



<li>A Fair Day – Malin Almheden</li>



<li>Inmarosa – Fabien Vivoix</li>



<li>Castor the Star – Kajsa Larelius</li>



<li>Ture L.A. – Ebba Göthberg</li>



<li>Gaspar d’Angis – Gauthier Baudouin</li>



<li>Working Class Hero – Lena Wahlgren</li>
</ul>



<p class="has-text-align-center wp-block-paragraph">***</p>



<p class="wp-block-paragraph"><strong>Alla deltagare i Paralympiatravet kommer att vara uppstallade i övervakningsstall inför loppet, detta i enlighet med paragraf 5 i Antidopningsreglementet. Det innebär att startande hästar i loppet måste vara på plats i anvisat stall på Åby klockan 08.00-10.00 på lördagen.<br>Det är första gången i år som ST har övervakningsstall i ett lopp.</strong></p>


<div class="factbox full ">
<div class="insidefactbox">
<div class="overflow">
<div class="height">
<div class="padding">
<div class="factvinjett">Fakta</div>
<h3 class="title">
									Alla vinnare av Paralympiatravet								</h3>
<div class="content">
<p class="wp-block-paragraph"><em>År, vinnare – Kusk (tränare) – Segertid – Förstapris (kr)</em><br />1979 <strong>Pershing</strong> – Berndt Lindstedt – 1.17,9a/2.100 – 60.000<br />1980 <strong>Don Ego</strong> – Stig H Johansson – 1.18,4/2.140 – 40.000<br />1981 Inställt<br />1982 <strong>Jana Bloc</strong> – Ove R Andersson – 1.18,8/2.140 – 40.000<br />1983 Inställt<br />1984 <strong>Einarsin</strong> – Tapio Perttunen – 1.15,1a/2.140 – 75.000<br />1985 <strong>Meadow Road</strong> – Torbjörn Jansson – 1.15,5a/2.140 – 300.000<br />1986 <strong>Utah Bulwark</strong> – Stig H Johansson – 1.14,5a/2.140 – 300.000<br />1987 <strong>Grades Singing</strong> – Ulf Thoresen (Herve Filion) – 1.15,4a/2.140 – 300.000<br />1988 <strong>Sugarcane Hanover</strong> – Gunnar Eggen – 1.14,4a/2.140 – 400.000<br />1989 <strong>Callit</strong> – Karl O Johansson – 1.14,9a/2.140 – 400.000<br />1990 <strong>Jet Ribb</strong> – Hans G Eriksson – 1.14,6a/2.140 – 500.000<br />1991 <strong>Karate Chop</strong> – Bo Näslund – 1.15,1a/2.140 – 500.000<br />1992 <strong>Bravo Sund</strong> – Jorma Kontio (Veijo Heiskanen) – 1.14,3a/2.140 – 500.000<br />1993 <strong>Queen L.</strong> – Stig H Johansson – 1.14,3a/2.140 – 500.000<br />1994 <strong>Queen L.</strong> – Stig H Johansson – 1.13,8a/2.140 – 500.000<br />1995 <strong>Copiad</strong> – Erik Berglöf – 1.13,6a/2.140 – 500.000<br />1996 <strong>Copiad</strong> – Erik Berglöf – 1.13,9a/2.140 – 800.000<br />1997 <strong>Scandal Play</strong> – Bo Eklöf (Lars Marklund)– 1.13,7a/2.140 – 800.000<br />1998 <strong>Rival Damkaer</strong> – Erik Adielsson (Tommy Strandqvist) – 1.16,2a/2.140 – 800.000<br />1999 <strong>Scandal Play</strong> – Bo Eklöf (Lars Marklund) – 1.14,8a/2.140 – 800.000<br />2000 <strong>Varenne</strong> – Giampaolo Minnucci (Jori Turja) – 1.12,7a/2.140 – 800.000<br />2001 <strong>Etain Royal</strong> – Jorma Kontio (Pirjo Vauhkonen) – 1.13,2a/2.140 – 800.000<br />2002 <strong>Varenne</strong> – Giampaolo Minnucci (Jori Turja) – 1.12,4a/2.140 – 800.000<br />2003 <strong>Gidde Palema</strong> – Åke Svanstedt – 1.13,1a/2.140 – 800.000<br />2004 <strong>Gidde Palema</strong> – Åke Svanstedt – 1.12,9a/2.140 – 800.000<br />2005 <strong>Gidde Palema</strong> – Åke Svanstedt – 1.12,9a/2.140 – 800.000<br />2006 <strong>Thai Tanic</strong> – Björn Goop (Olle Goop) – 1.13,0a/2.140 – 1.000.000<br />2007 <strong>Gentleman</strong> – Thomas Uhrberg (Kari Lähdekorpi) – 1.12,8a/2.140 – 1.000.000<br />2008 <strong>Torvald Palema</strong> – Åke Svanstedt – 1.12,2a/2.140 – 1.500.000<br />2009 <strong>Triton Sund</strong> – Örjan Kihlström (Stefan Hultman) – 1.11,1a/2.140 – 1.500.000<br />2010 <strong>Copper Beech</strong> – Conrad Lugauer – 1.11,6a/2.140 – 1.500.000<br />2011 <strong>Brioni</strong> – Joakim Lövgren – 1.11,4a/2.140 – 1.500.000<br />2012 <strong>Commander Crowe</strong> – Christophe Martens (Fabrice Souloy) – 1.12,2a/2.140 – 1.500.000<br />2013 <strong>Maharajah</strong> – Örjan Kihlström (Stefan Hultman) – 1.11,0a/2.140 – 1.500.000<br />2014 <strong>Solvato</strong> – Veijo Heiskanen – 1.10,9a/2.140 – 1.500.000<br />2015 <strong>B.B.S.Sugarlight</strong> – Peter Untersteiner (Fredrik Solberg) – 1.10,7a/2.140 – 1.500.000<br />2016 <strong>Your Highness</strong> – Björn Goop (Fabrice Souloy) – 1.10,9a/2.140 – 1.500.000<br />2017 <strong>Lionel</strong> – Göran Antonsen (Daniel Redén) – 1.10,9a/2.140 – 1.500.000<br />2018 <strong>Ringostarr Treb</strong> – Wim Paal (Jerry Riordan) – 1.10,0a/2.140 – 1.500.000<br />2019 <strong>Handsome Brad</strong> – Carl Johan Jepson (Ulf Stenströmer) – 1.11,0a/2.140 – 1.500.000<br />2020 <strong>Elian Web</strong> – Jorma Kontio (Katja Melkko) – 1.12,2a/2.140 – 1.000.000<br />2021 <strong>Delia du Pommereux</strong> – Eric Raffin (Sylvain Roger) – 1.10,9a/2.140 – 1.500.000<br />2022 <strong>Who&#8217;s Who</strong> – Örjan Kihlström (Pasi Aikio) – 1.11,9a/2.140 meter – 1.500.000<br />2023 <strong>San Moteur</strong> – Björn Goop – 1.10,8a/2.140 – 1.500.000<br />2024 <strong>Önas Prince</strong> – Per Nordström – 1.10,1a/2.140 meter – 1.500.000<br />2025 <strong>Borups Victory</strong> – Daniel Wäjersten – 1.10,0a/2.140 meter – 1.500.000</p>
</p></div>
</p></div>
</p></div>
</p></div>
</p></div>
</p></div>
