
<p class="has-drop-cap wp-block-paragraph">1Det började med 19 raka segrar och slutade på 35 triumfer på 93 starter. <strong>Legolas</strong> (e. Glasgow) var hästen som sprang rakt in i alla svenska travhjärtan på 1980-talet, ja han tog även människor utanför sporten med storm. Som när han lockade Carola Häggkvist till både Axevalla och Solvalla 1983 när travet samlade in pengar till Föreningen Artister Mot Narkotika (FAMN). <br>– Frances Bulwark och Ego Boy hade en sådan status ute i stugorna och därefter kom Legolas. Jag är rädd för att det är så illa att han faktiskt är den senaste och kanske också blir den siste. Vi som var inne i branschen hyllade stjärnor som Victory Tilly och Järvsöfaks när de stod på topp och det har ju verkligen funnits många hästar som varit bättre än Legolas här i Sverige, men några folkhemshjältar har de aldrig blivit, sade Thomas Nilsson själv i en intervju med Sulkysport för fem år sedan.</p>



<p class="wp-block-paragraph"><a href="https://sulkysport.se/wp-content/uploads/2020/12/sulkysport2019legolas.pdf" target="_blank" rel="noreferrer noopener">Här är hela intervjun med Thomas Nilsson om livet med Legolas.</a></p>



<figure class="wp-block-image size-sulky-mellan2"><img src="https://sulkysport.se/wp-content/uploads/2020/12/thomasnilsson01-617x333.jpg" alt="" class="wp-image-124095"/><figcaption class="wp-element-caption">Sagan om Legolas blev också bok på 1980-talet och där plockar Thomas Nilsson fram den bild på Legolas som han älskar mest – när hästen sträcker ut i full fart, fångad av Stefan ”Tarzan” Melanders kamera. Den bilden finns också i form av en oljemålning i Thomas hem. Foto Göran Lindskog/Sidmakarn</figcaption></figure>



<p class="wp-block-paragraph"><strong>Legolas Minne körs för tionde gången och här är alla tidigare vinnare:</strong></p>



<ul class="wp-block-list">
<li>2015 Dream Takes Time (e. Andover Andover – Peter Untersteiner – 1.12,8a</li>



<li>2016 Spring Erom (e. Gentle Star) – Christoffer Eriksson (Dan Widegren) – 1.14,0a</li>



<li>2017 Västerboonthenews (e. Credit Winner) – Örjan Kihlström (Lars Brindeborg) – 1.13,0a</li>



<li>2018 Nadal Broline (e. Yankee Glide) – Erik Adielsson (Reijo Liljendahl) – 1.10,6a</li>



<li>2019 Stepping Spaceboy (e. Dream Vacation) – Stefan Söderkvist (Admir Zukanovic) – 1.12,0a</li>



<li>2020 Very Kronos (e. Ready Cash) – Erik Adielsson (Svante Båth) – 1.11,7a</li>



<li>2021 Ble du Gers (e. Quinoa du Gers) – Björn Goop (Frode Hamre) – 1.12,4a</li>



<li>2022 Mister F.Daag (e. Conway Hall) – Robin Bakker (Paul Hagoort) – 1.13,0a</li>



<li>2023 Stoletheshow (e. Dream Vacation) – Örjan kihlström (Frode Hamre) – 1.13,5a</li>
</ul>



<p class="wp-block-paragraph">* 2018 och 2019 var distansen 1.640 meter. Övriga år, liksom i år, har det handlar om 2.140 meter.</p>



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



<p class="has-drop-cap wp-block-paragraph">2Fyra av landets hetaste travare dyker upp på Åby idag, men bara tre av dem i Legolas Minne. Elisabeth Almheden väljer att starta Elitloppshästen <strong>A Fair Day</strong> (e. Maharajah) i ett B-tränarlopp!</p>



<p class="wp-block-paragraph">Dunderloppet Legolas Minne då? Ja, från framspår finns Adrian Kolgjinis Europaderbyvinnare <strong>Barack Face</strong> (e. Ready Cash), som siktas mot Pris Tenor de Baune på Vincennes den den 22 december över distansen 2.700 meter med prischeck på 108.000 euro och plats i Prix d’Amérique till vinnaren.<br>Till det loppet är redan <strong>San Moteur</strong> (e. Panne de Moteur) inkvalad efter andraplatsen i Prix de Bretagne (€120.000) och fokus ligger helt på sista söndagen i januari.</p>



<p class="wp-block-paragraph">Per Nordströms Elitloppsfinalist <strong>Önas Prince</strong> (e. Chocolatier) då? Efter segern i Ulf Thoresens Minne i juli tvingades hästen till operation. Comebacken i Halmstad lämnade inget övrigt att önska och nu väntar ett stjärnmöte.<br>– Innerst inne tror jag inte att vi inte rår på San Moteur med den form jag har på min häst för dagen. Jag skulle tippa den är på 85-90 procent, men jag är fullständigt nöjd med min häst och gråter inte blod om vi skulle hamna utvändigt om ledaren, han är en tuff konkurrent att ha på utsidan, sade Per Nordström till V65 Direkt.</p>



<p class="wp-block-paragraph"><a href="https://sulkysport.se/spelstugan/v75-tips-tva-vassa-spikar-leder-till-full-pott/" target="_blank" rel="noreferrer noopener">Här är Sulkysprts stora tipsgenomgång med analyser, spikar och drag till dagens V75-omgång.</a></p>



<p class="wp-block-paragraph">Hos vår samarbetspartner Travnet finns andelar till dagens V75-omgång på Högkvarteret.<br><a href="https://www.atg.se/hogkvarteret/V75_2024-12-14_6_5" target="_blank" rel="noreferrer noopener">Här är alla andelar!</a></p>



<p class="wp-block-paragraph">Lördagskvällen avslutas med breddlopp i Eskilstuna (start 18.30). <a href="https://sulkysport.se/wp-content/uploads/2024/12/241214.pdf">Här är startlistorna!</a></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/11/attachment1-617x411.jpeg" alt="" class="wp-image-664390"/><figcaption class="wp-element-caption">Enkelt blev det för Working Class Hero och Mathieu Mottier för 2,5 veckor sedan. Foto: Scopdyga.</figcaption></figure>



<p class="has-drop-cap wp-block-paragraph">3I våras tog Jörgen Westholm-tränade <strong>Working Class Hero</strong> (e. Village Mystic) två raka segrar på Vincennes. Efter en sommar i Sverige var han tillbaka med dunder och brak på kolstybben för 2,5 veckor sedan när han vann Prix de Bourigny (€71.000) på 1.10,3a/2.100 meter tillsammans med Mathieu Mottier.<br>I eftermiddag är Working Class Hero tillbaka på Vincennes tillsammans med Mottier i Grupp III-loppet Prix de Reims (€80.000) över medeldistans med startbil. Working Class Hero inleder från spår två och ställs bland annat mot tre hästar från dansken Erik Bondos stall med fyraårige <strong>Edgar Saba</strong> (e. Exploit Caf) i spetsen.</p>



<p class="wp-block-paragraph">Det är en hel del blågult på Vincennes och tre av fyra europeiska lopp har svenskfödda travare i startlistan. Prix de Saint-James (€75.000) ser Sabine Kagebrants <strong>Iznogoud Am</strong> (e. Muscle Hill) med Jean Michel Bazire och <strong>Self Explosive</strong> (e. Explosive Matter) med Benjamin Rochard, samt Johan Untersteiners tysk <strong>Toto Barosso</strong> (e. Ready Cash) med Mathieu Mottier.</p>



<p class="wp-block-paragraph">Jörgen Westholm startar <strong>Made Of Stars</strong> (e. Super Photo Kosmos) i Prix de Gisors (€59.000). Bland motståndarna finns exporterade, svenskfödda duon <strong>Silver Bullit</strong> (e. Orlando Vici) och <strong>Staro Mojito</strong> (e. Make It Happen).</p>



<p class="wp-block-paragraph">Lördagens högst doterade löpning är grupp II-loppet Prix Emmanuel Margouty (€120.000) för tvååriga hingstar, där Philippe Allaires <strong>Monzon Normand</strong> (e. Hohneck) visat mest hittills.</p>



<p class="wp-block-paragraph"><a href="https://sulkysport.se/trav-och-galopp/paris-vincennes-2024-12-14/" target="_blank" rel="noreferrer noopener">Här är startlistorna till dagens tävlingar på Vincennes.</a></p>



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



<p class="has-drop-cap wp-block-paragraph">4Svenskfödda stjärnor på SM-banan Åby och ett ”svenskt mästerskap” i finska Uleåborg samma eftermiddag. Oulo Grand Prix (€19.600) för varmblod med 8.000 euro till vinnaren ser åtta av nio deltagare födda i Sverige.</p>



<p class="wp-block-paragraph">Skellefteåamatören Bert Pettersson tränar två av dem i <strong>Selmer I.H.</strong> och <strong>Bravo Sabotage</strong>, medan Petri Salmela startar <strong>Hector Sisu</strong> och <strong>Leave Your Sox On</strong>. Den ende som inte är svenskfödd i loppet är <strong>Quick Vald</strong>, som är född i Tyskland.</p>



<p class="wp-block-paragraph"><strong>Startlista Oulu Grand Prix</strong><br><em>2.120 meter autostart:</em></p>



<ol class="wp-block-list">
<li>Hector Sisu (e. Zola Boko) – Kari Alapekkala</li>



<li>Combat Fighter (e. From Above) – Santtu Raitala</li>



<li>Djokovic (e. Bold Eagle) – Mauri Jaara</li>



<li>Selmer I.H. (e. Love You) – Hannu Torvinen</li>



<li>Dozen Of Oysters (e. Zola Boko) – Tuukka Varis</li>



<li>Adde S.H. (e. Nu Pagadi) – Niko Jokela</li>



<li>Quick Vald (e. Classic Photo) – Jukka-Pekka Kauhanen</li>



<li>Bravo Sabotage (e. From Above) – Tuomas Pakkanen</li>



<li>Leave Your Sox On (e. Trixton) – Iikka Nurmonen</li>



<li>Mandela Zon (e. Maharajah) – struken</li>
</ol>



<p class="wp-block-paragraph">Det är mycket svenskt under Uleåborgs stordag i vintertid och fem tränare har hästar till start:<br><strong>Sandra Eriksson</strong>, Boden: Gorm, B.Sacamano<br><strong>Junita Luttunen</strong>, Boden: Nordic Beauti, Black Luca, <br><strong>Hanna Olofsson</strong>, Boden: Sensitive Tile, Ja Ba Da Ba Doo, Oak L.A., Last Dying Breath<br><strong>Bert Pettersson</strong>, Skellefteå: Queen Håleryd, Ludovie Sisu, Selmer I.H., Bravo Sabotage<br><strong>Petri Salmela</strong>, Boden: Hector Sisu, Leave Your Sox On</p>



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



<p class="has-drop-cap wp-block-paragraph">5Norges bästa kallblodssto i år är femåriga <strong>Christina K.</strong> (e. Odd Herakles) med segrar i Norskt Mästerskap för ston, dubbelcupsfinalen Erik Perssons Memorial i Årjäng, DNT:s Femåringslopp för ston och Veikle Balders stofinal för femåringar på meritlistan.<br>Hon skulle ha tävlat på Bjerke ikväll (första start 19.15) där det är rikstotofinaler och för hennes del final i stocupen, men så blir inte fallet. Christina K. är skadad och tränaren Erik Killingmo befarar det värsta, enligt Trav- og Galopp-Nytt.<br>– När det var 100 meter kvar av sista intervallen tappade hon travet. Troligen är det en senskada och hon är såpass halt att jag tror det är fara för karriären, säger Erik Killingmo till TGN.</p>



<p class="wp-block-paragraph">Nu väntar ultraljudsundersökning och om prognosen är god kan det bli träning igen. Annars blir hon fölsto till våren enligt Killingmo.</p>



<p class="wp-block-paragraph">De svenska tränarna saknas på Bjerke, men flera svenskfödda travare jagar goda prischeckar i finalerna. Bland annat tar Thor Borg ut svenska Breeders Crown-finalisten <strong>Maharasha</strong> (e. Maharajah) i stofinalen. Maharasha fick kort vila efter BC-finalen i Eskilstuna när hon vann ett stolopp på Orkla Arena redan sju dagar senare och nu blir det finaldags med 100.000 kronor i förstapris.</p>



<p class="wp-block-paragraph"><a href="https://www.travsport.no/travbaner/bjerke-travbane/startlist/2024-12-14" target="_blank" rel="noreferrer noopener">Här är startlistorna till kvällens tävlingar på Bjerke.</a></p>



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



<p class="has-drop-cap wp-block-paragraph">6Idag avgörs finalen i Inter Dominion Trot ($150.000) i Menangle och bland finalisterna finns John ”Boko” Bootsman-ägda <strong>Aldebaran Vera</strong> (e. Trixton), 1.11,1/$168.405. <br>– Jag köpte Aldebaran Vera när hon var tre månader gammal, berättar John Bootsman. </p>



<p class="wp-block-paragraph">Det Margare Lee-tränade sexåriga stoet har vunnit elva lopp på 39 starter. I försöken till Inter Dominon Trot har Aldebaran Vera slutat fyra, trea och trea. Motståndet är tufft och favorit till segern är fyraårige <strong>The Locomotive</strong> (e. Muscle Mass) som gjort rent hus och vunnit samtliga tre försök för sin tränare Brad Hewitt.</p>



<p class="wp-block-paragraph"><strong>Inter Dominion Trot ($150.000)</strong><br>Äldre travare, 2.300 meter autostart:<br><em>Häst (far) – Kusk</em></p>



<ol class="wp-block-list">
<li>Toro Stride (e. Love You) – Cameron Hart</li>



<li>Aldebaran Vera (e. Trixton) – Will Rixon</li>



<li>Keayang Chucky (e. Love You) – Jason Lee</li>



<li>The Locomotive (e. Muscle Mass) – Brad Hewitt</li>



<li>Queen Elida (e. Love You) – Chris Alford</li>



<li>Mufasa Metro (e. Father Patrick) – Ewa Justice</li>



<li>Aldebaran Zeus (e. Muscle Hill) – Blake Fitzpatrick</li>



<li>Speedy Lover (e. Love You) – Chris Geary</li>



<li>Keayang Stuka (e. Wishing Stone) – Lochie Cook</li>



<li>Royal Dan (e. Orlando Vici) – Jack Callaghan</li>



<li>Plymouth Chubb (e. Majestic Son) – Kerryn Manning</li>



<li>Parisian Artiste (e. Love You) – Tayla French</li>



<li>Courage Stride (e. Muscle Hill) – struken</li>



<li>Constantinople (e. Trixton) – Luke McCarthy</li>
</ol>



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



<p class="has-drop-cap wp-block-paragraph">7Han har vunnit Deutschland-Cup (€50.000) i Hamburg och Prix d&#8217;Avesnieres (€33.000) i Laval och slutat trea på Vincennes. Innanför Sveriges gränser finns triumfen i Ullbergs Minne på hemmabanan Axevalla. Ikväll är trippelmiljonären <strong>Dats So Cool</strong> (e. Classic Photo), 1.09,5ak/3.148.689 kr, en av 14 starthästar som bjuds ut till försäljning på Traveras lördagsauktion.</p>



<p class="wp-block-paragraph">Totalt består den digitala katalogen av 31 hästar och bland tolv fölston finns bland andra avelshingsten Traders mamma <strong>Graziella</strong> (dräktig med Italiano Vero), Global Badmans mamma <strong>Karalta Bye Bye</strong> (dräktig med Hohneck) och <strong>Lady Broadway</strong> (e. Broadway Hall). Den sistnämnda är dräktig med Ready Cash!</p>



<p class="wp-block-paragraph">En ettåring med Django Riff som far och fyra tvååringar med fäderna Nuncio, Southwind Frank, Hayden Hanover och Wellino Boko kompletterar utbudet.</p>



<p class="wp-block-paragraph"><a href="https://www.travera.nu/kopa-hast/" target="_blank" rel="noreferrer noopener">Här går det att se alla hästar som ska säljas och följa auktionen under kvällen.</a></p>

Fokustema
Sju nyheter vid sju
Läs senare
Stjärnorna hyllar folkhjälten
När travets hjälte mötte Carola. Stjärnhästarna i minnesloppet. Gott om svneskar på Vincennes – och svenskt mästerskap i Finland. Bootsman jagar storseger ”down under”. Trefaldig miljonär säljs ikväll.
Detta och mer i lördagsmorgonens nyhetssvep.
Detta och mer i lördagsmorgonens nyhetssvep.
