
<p class="has-drop-cap">1Han är streckfavorit i fyra av sju V75-avdelningar. Daniel Wäjersten har verkligen välladdat när eftermiddagens V75-omgång avgörs i Östersund (första start 14.45).<br><strong>Young Yack</strong> (V75-1) är hårdast betrodd med 60 procent, <strong>Global Escape</strong> (V75-5) är streckad på 49 procent, <strong>Competivo</strong> (V75-7) på 47 procent och <strong>Lindysmusclemania</strong> (V75-2) på 36 procent just nu.</p>



<p>Sulkysports tipsexpert lutar sig mot Wäjersten när det gäller val av singelstreck till V75-omgången och fastnar för två av hästarna. En av dem är Young Yack (e. Nuncio) i inledningen. Hästen har tävlat barfota bak i de fyra senaste starterna, men nu blir det skor runt om sedan barfotaförbudet trätt i kraft.<br>– Vi måste vikta hästen lite mer fram, det är negativt, men han står bra till i nuvarande klass. Han gick med skor i början av karriären, man har en magkänsla och man kan ha fel, men jag tror att det ska fungera hyggligt, sade Daniel Wäjersten till V65 Direkt.</p>



<p><a href="https://sulkysport.se/spelstugan/v75-tips-wajersten-visar-vagen-mot-sju-ratt/" target="_blank" rel="noreferrer noopener">––> Här är Sulkysports stora tipsgenomgång till dagens V75-tävlingar.</a></p>



<p>Det högst doterade loppet i Östersund är dubbelcupens final med 200.000 kronor till vinnaren, som namngivits Rogers lopp efter Sven O Perssons stjärna på 1940- och 1950-talet. <strong>Roger</strong> (född 1939 e. Junger) gjorde 275 starter (78-63-63) vann blev svensk mästare tre gånger, 1948, 1951 och 1953. Sven O Persson var den kanske viktigaste initiativtagaren när travbanan i Östersund byggdes och hade premiär redan 1936.<br>Ingen Östersundstränad häst finns med i Rogers lopp, men kanske kan jämtlandsuppfödde Mats E Djuse ordna lite hemmajubel bakom Jörgen Westholm-tränade <strong>Guli Hektor</strong> (e. Tekno Odin) trots bakspår på tillägg.</p>



<p>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-07_33_5" target="_blank" rel="noreferrer noopener">Här är alla andelar!</a></p>



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



<figure class="wp-block-image size-sulky-mellan2"><img src="https://sulkysport.se/wp-content/uploads/2023/10/kilmisterbsm230930adamstromstalltz-617x440.jpg" alt="" class="wp-image-503322"/><figcaption class="wp-element-caption">Kilmister vid seger på Red Mile som treåring. Foto: Adam Ström/stalltz.se</figcaption></figure>



<p class="has-drop-cap">2Det blir svensktränade och svenskfödda hästar i dagens två största lopp på Vincennes (första start 13.23). Det handlar om Grupp II-loppen för fyraåringar, Prix Octave Douesnel (€120.000) för hingstar och stoloppet Prix Ariste Hemard (€120.000).</p>



<p>Störst blågult intresse finns bland hingstarna med en kvartett till start. Sabine Kagebrant startar duon <strong>Frank S.H. </strong>(e. Fourth Dimension) och <strong>Kilmister </strong>(e. Chapter Seven), David Persson har Kungapokalsvinnaren <strong>Baron Tilly </strong>(e. Ready Cash) och Fredrik Wallin mönstrar <strong>Immortal Doc </strong>(e. Brillantissime). Den sistnämnde körs av Björn Goop.<br>En som spänner bågen är amatörtränaren Mikael Melefors med Face Time Bourbon-dottern <strong>Naomi Bros</strong> i stoloppet. Efter loppet stannar Naomi Bros i Frankrike och går i träning till Nicolas Bazire. Ytterligare svenskfött blir det genom Erwin Bots Oakstvåa ifjol, <strong>Ninetta Boko</strong> (e. Father Patrick).</p>



<p>Ytterligare två lopp är öppna för europeiska hästar och Johan Untersteiner finns med i båda. Halmstadtränaren avtjänar en avstängning, men får köra i Grupp III-lopp vilket gäller Prix Narquois (€80.000). Han sitter i sulkyn bakom femårige <strong>Global Dubhe</strong> (e. Brillantissime), som gör första starten på fransk mark. Fjolårets Derbyfyra har tidigare tävlat me framgång i både Tyskland och Nederländerna.<br><strong>Behind Bars</strong> (e. Maharajah) kommer från seger i Grand Prix d’Automne (€34.000) i Salon de Provence i Frankrikecomebacken och körs nu av Gabriele Gelormini i Prix d’Hautefort (€59.000).</p>



<p><a href="https://sulkysport.se/trav-och-galopp/paris-vincennes-2024-12-07/">Här är startlistorna till Vincennes tävlingar idag.</a></p>



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



<figure class="wp-block-image size-sulky-mellan2"><img src="https://sulkysport.se/wp-content/uploads/2020/09/bjorngoop-617x333.jpg" alt="" class="wp-image-112416"/><figcaption class="wp-element-caption">Björn Goop reser till andra sidan jordklotet efter nyår. Foto Mathias Hedlund/Sulkysport</figcaption></figure>



<p class="has-drop-cap">3Nu är alla kuskar klara till kusktävlingen Ultimate Driver Championship på Albion Park i Australien den 21-22 februari nästa år och Björn Goop blir ensam europé. Under två dagar ska det tävlas i tio lopp om totalt 250.000 dollar, varav segraren erhåller 100.000 dollar. </p>



<p>Tio företag har köpt lika många kuskar för 20.000 dollar vardera, varav en av dem är loppets sponsor Ladbrokes. Förutom Björn Goop kommer följande kuskar delta: Dexter Dunn, Yannick Gingras, Garry Hall Jr, Brad Hewitt, Nathan Dawson, Carter Dalgety, Peter McMullen, Kate Gath och Angus Garrard. </p>



<p>Hästarna kommer via en ”snake order draft” (fördelningssystem) fritt förhandlas mellan de tio kuskarna/lottköparna. </p>



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



<p class="has-drop-cap">4Klart godkänd spurt som trea, längden bakom vinnaren <strong>Phoenix Photo</strong> (e. Super Photo Kosmos), i Silverhästen på Solvalla i lördags. Redan ikväll är svenskägde mångmiljonären <strong>Stoletheshow</strong> (e. Dream Vacation) tillbana på banan. Tränaren Frode Hamre gör resan till Forus (första start 19.15) ikväll i jakt på hästens 13:e årsseger.</p>



<p>Uppgiften är åttondespår bakom bilen över 2.040 meter och bland motståndarna finns förre stallkamraten <strong>Feydeau Seven</strong> (e. Redeo Josselyn), som numera återfinns hos Kjetil Djöseland.</p>



<p><a href="https://sulkysport.se/wp-content/uploads/2024/12/fo20241207baneprogram.pdf" target="_blank" rel="noreferrer noopener">Här är startlistorna till Forus.</a></p>



<p>Samtidigt som Forus kvällstävlingar blir det även lopp på svensk mark. Gävle (första start 18.30) har breddlopp till kvällsakt, spetsat med ett B-tränarlopp med 35.000 kronor till vinnaren. Kvällen rikaste häst är Jörgen Westholm-tränade <strong>Rio Alta Wine</strong> (e. Readly Express), som tillsammans med Victor S Sundgren jagar startpoäng för större uppgifter än breddlopp.</p>



<p><a href="https://sulkysport.se/wp-content/uploads/2024/12/241207.pdf" target="_blank" rel="noreferrer noopener">Här är startlistorna till lördagens svenska tävlingar.</a></p>



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



<p class="has-drop-cap">5Fjärde starten på 17 dagar väntar för svenskfödda <strong>Janis Joplin Sisu</strong> (e. Trixton) i Tammerfors idag. Henna Halme tränar stoet, som hittat en finfin formtopp i slutet av säsongen.</p>



<p>Janis Joplin Sisu vann både försök och final i en stocup på Vermo under de tio sista dagarna av november och hann dessutom med att sluta tvåa i försök till GLI Grand Prix i Tammerfors mellan de två Vermostarterna.<br>I eftermiddag ligger 28.800 euro i potten, varav vinnaren tar 12.000 euro, i finalen i GLI Grand Prix-final. Henna sitter som oftast själv i sulkyn bakom stoet som sprungit in 30.655 euro så här långt. Hon är lillasyster till Evil Urges (485.824 dollar) och svebskfödda miljonärskan Flaming Ace Sisu.</p>



<p>Den segerrikaste svenskfödde travaren 2023 var Reima Kuislas <strong>Mandela Zon</strong> (e. Maharajah), som plockade 25 segrar (och nio andrapris) på 40 starter förra året! I år har det ”bara” blivit fyra triumfer för sjuåringen, som ändå fått upp ångan och ståtar med två raka när han kommer ut i snabbloppet i Tammerfors idag. Där ställs han bland annat mot svenskfödda trion <strong>Hierro Boko, Farzad Boko</strong> och <strong>Ubiquarian Face</strong>.</p>



<p><a href="https://heppa.hippos.fi/heppa/app?ct=YXBwbGljYXRpb24vcGRm&#038;d=dHJ1ZQ%3D%3D&#038;dr=&#038;f=b2hqZWxtYXRpZWRvdC5UXzA3LjEyLjIwMjQucGRm&#038;m=3xotp1AojuF%2FLm4tyzois6YSt%2Fs%3D&#038;service=pdftmp" target="_blank" rel="noreferrer noopener">Här är startlistorna till Tammerfors tävlingar.</a></p>



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



<figure class="wp-block-image size-sulky-mellan2"><img src="https://sulkysport.se/wp-content/uploads/2022/08/perkinsdwm220809adamstromstalltz-617x396.jpg" alt="" class="wp-image-339253"/><figcaption class="wp-element-caption">Perkins. Foto: Adam Ström/stalltz.se</figcaption></figure>



<p class="has-drop-cap">6Travera bjuder in till auktion ikväll och katalogen innehåller 31 nummer. Mest meriterad är femårige halvmiljonären <strong>Perkins</strong> (e. Nuncio), för dagen skadad, som segrade i STL-lopp förra hösten och avslutade säsongen med andraplatsen i klass I-finalen.<br>Fyraårige <strong>Önas Spartakus</strong> (e. International Moni) närmar sig första halvmiljonen insprunget och var finalist i Kungapokalen i våras.</p>



<p>Sju fölston, två tvååringar (e. Walner respektive Power) samt livstids betäckningsrätt med Önas Pince och Trixton finns också i den digitala katalogen. </p>



<p><a href="https://www.travera.nu/kopa-hast/" target="_blank" rel="noreferrer noopener">Här går det att se alla hästar som bjuds ut och följa budgivningen under kvällen.</a></p>



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



<p class="has-drop-cap">7Ny repris för <strong>Queen Elida</strong> och <strong>The Locomotive</strong>? Idag avgörs den sista försöksrundan i Inter Dominion Trotting Championship ($20.000) på Menangle och både Queen Elida och The Locomotive har vunnit dubbla försök och slipper möta varandra idag också när distansen är 2.300 meter. </p>



<p>Finalen i Inter Dominion Trotting Championship ($150.000) avgörs den 14 december på Menangle och då väntar ett förstapris på 78.000 australienska dollar, cirka 550.000 svenska kronor. </p>



<p><strong>Inter Dominion Trotting Championship ($20.000) – försök 5:</strong><br>Äldre travare, 2.300 meter autostart.<br><em>Namn – Körsven</em></p>



<ol class="wp-block-list">
<li>Sunny Gee – Robert Morris</li>



<li>Keayang Chucky – Jason Lee</li>



<li>The Locomotive – Brad Hewitt</li>



<li>Mufasa Mestro – Ewa Justice</li>



<li>Toro Stride – Cameron Hart</li>



<li>Keayang Stuka – Will Rixon</li>



<li>Plymouth Chubb – Kerryn Manning</li>



<li>Constantinople – Luke McCarthy</li>



<li>Aldebaran Zeus – Chris Alford</li>
</ol>



<p><strong>Försök 6:</strong></p>



<ol class="wp-block-list">
<li>Royal Dan – Jack Callaghan</li>



<li>Queen Elida – Chris Alford</li>



<li>Parisian Arstiste – Tayla French</li>



<li>London to A Brick – struken</li>



<li>Aldebaran Vera – Jason Lee</li>



<li>Affaire de Cover – Robert Morris</li>



<li>Courage Stride – Blake Fitzpartrick</li>



<li>Speedy Lover – Chris Geary</li>
</ol>



<p><strong>Tidigare försöksvinnare i Inter Dominion Trotting Championship:</strong><br><em>Datum – Vinnare – Segertid</em></p>



<ul class="wp-block-list">
<li>29 november – The Locomotive (Muscle Mass) – 1.15,0a</li>



<li>29 november – Queen Elida (e. Love You) – 1.13,0a</li>



<li>4 december – The Locomotive (Muscle Mass) – 1.11,8a</li>



<li>4 december – Queen Elida (e. Love You) – 1.13,0a</li>
</ul>

Fokustema
Sju nyheter vid sju
Läs senare
Hur många vinner Wäjersten?
Fyra streckfavoriter från Wäjersten på V75. Fem svenskfödda fyraåringar i storlopp på Vincennes. Goop ende europé ”down under”. Hamres stjärna på banan igen. Kvalfyllt i Nya Zeeland.
Detta och mer i lördagens nyhetssvep.
Detta och mer i lördagens nyhetssvep.
