
<p class="has-drop-cap wp-block-paragraph">1Fyra av de sex senaste åren har Joakim Lövgren blivit kuskchampion på hemmabanan Jägersro. Om det ska bli ytterligare en titel 2025 kan han bygga upp siffrorna i eftermiddag när V75 avgörs på hemmabanan. Lövgren kör fem hästar, varav fyra inom V75, på Jägersro (start 14.45).</p>



<p class="wp-block-paragraph"><strong>Nasha</strong> (e. Nuncio) var trea i ett klass II-försök på hemmaplan i slutet av november från åttondespår bakom bilen. Nu får hon en ny chans i samma klass och den här gången med siffran fem på vojlocken.<br>– Hon är en läcker travare och jag är alltid nöjd med henne. Hon passar bättre på sprint än 2.100 och bättre på snabb bana än tung bana. Senast fick hon väldigt fina förutsättningar och löste uppgiften. Läget ska vara bra, hon kan trampa iväg bra. Hon är inte vek på något sätt, sade Joakim Lövgren till V65 Direkt.</p>



<p class="wp-block-paragraph">Spelarna är med på noterna när det gäller Nasha, som tillhör de fyra mest streckade hästarna i jackpotomgången när uppgiften är 1.640 meter autostart på en normalt bra Jägersrooval.</p>



<p class="wp-block-paragraph"><a href="https://sulkysport.se/wp-content/uploads/2025/01/18v75.pdf" target="_blank" rel="noreferrer noopener">Här är startlistorna till dagens tävlingar. </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/2022/05/bakkerrobinhagoortpaul220507adamstromstalltz-617x455.jpg" alt="" class="wp-image-298923"/><figcaption class="wp-element-caption">Robin Bakker och Paul Hagoort är duon bakom V75-spiken Bourbonista. Foto: Adam Ström/stalltz.se</figcaption></figure>



<p class="has-drop-cap wp-block-paragraph">216,5 miljoner kronor extra i sjurättspotten och uppskattningsvis 40 miljoner kronor till en ensam vinnare. Det är förutsättningarna för V75 på Jägersro idag. </p>



<p class="wp-block-paragraph">Sulkysports tipsexpert har analyserat omgången noga och sammanfattar övrningarna på Jägersro så här:<br><em>”Spelmässigt ser omgången vidöppen ut och det som kittlar lite extra är att det finns en jackpott på 40 miljoner kronor att spela om. Mitt bästa singelstreck hamnar på Bourbonista i V75-5 som fick ett perfekt läge och har en passande uppgift för den framgångsrika duon Paul Hagoort (tränare) och Robin Bakker (kusk).”</em></p>



<p class="wp-block-paragraph"><a href="https://sulkysport.se/spelstugan/v75-tips-bakker-bankas-i-vidoppen-omgang/" target="_blank" rel="noreferrer noopener">––> Här är Sulkysports stora tipsgenomgång till jackpotomgången.</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_2025-01-18_7_5" target="_blank" rel="noreferrer noopener">Här är alla andelar!</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/2025/01/prixdelille1-617x324.jpg" alt="" class="wp-image-675434"/><figcaption class="wp-element-caption">Jack Tonic vinner för Théo Duvaldestin och ute i banan spurtar Indy Rock (15) till andraplatsen. Foto: Gerard Forni</figcaption></figure>



<p class="has-drop-cap wp-block-paragraph">3Fem svensktränade hästar dyker upp i dagens största lopp på Vincennes, Prix de Brest (€90.000) med 40.500 euro till vinnaren. Daniel Redén mönstrar en duo i <strong>Jaguar Dream</strong> (e. Love You) och <strong>Indy Rock</strong> (e. Readly Express), lika många starthästar har Johan Untersteiner genom <strong>Global Dubhe</strong> (e. Brillantissime) och <strong>Toto Barosso</strong> (e. Ready Cash), medan Sabine Kagebrant startar <strong>Iznogoud Am</strong> (e. Muscle Hill).<br>Loppet har samlat tolv hästar med elva på startfållan 2.850 meter, medan Matthieu Abrivard plockar ut fjolårets Elitloppshäst <strong>Gaspar de Brion</strong> (e. Singalo) från 25 meters tillägg. Gaspar de Brion slutade femma i Elitloppsförsöket som vanns av finalvinnaren Horsy Dream (e. Scipion du Goutier).</p>



<p class="wp-block-paragraph">Jörgen Westholms femåring <strong>Caviar From Mine</strong> (e. S.J.’s Caviar) slutade femma i sulkydebuten på Vincennes för knappt två veckor sedan. I Prix Roxane Grif (€46.000) över 2.850 meter gör han livets första start i monté med Alexandre Abrivard i sadeln. Det handlar om ett femåringslopp och Caviar From Mine har elva motståndare.</p>



<p class="wp-block-paragraph">Svenskt i övrigt? Ja, Björn Goop är på plats och kör två hästar åt Richard Westerink, däribland <strong>Ideal San Leandro</strong> (e. Timoko) i Prix de Granville (€68.000). Jarmo Niskanen tar ut <strong>Loumanas</strong> (e. Uriel Speed) och Marie Norberg <strong>Lady d’Elfe</strong> (e. Bon Copain) i Prix de Darnetal (€35.000). </p>



<p class="wp-block-paragraph"><a href="https://sulkysport.se/trav-och-galopp/paris-vincennes-2025-01-18/" 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">4En norsk drömgräns ska passeras på Jarlsberg ikväll när svenskägde – Global Glide AB, Skövde – tioåringen <strong>Stoletheshow</strong> (e. Dream Vacation) startar i högsta klassen i den norska V75-omgången på Jarlsberg. Frode Hamres travare ståtar nämligen med 14.908.081 norska kronor på kontot och förstapriset ikväll är 100.000 kronor!<br>Frode Hamre är själv på semester i Thailand och sätter upp Vidar Hop som kusk bakom mångmiljonären.</p>



<p class="wp-block-paragraph">Största hotet mot Stoletheshow kan komma från Sverige i form av Årjängsamatören Helen Edlunds tioåring <strong>Beartime</strong> (e. Pastor Stephen). Beartime har tävlat hela vintern och kommer närmast från fjärdeplatsen i Färjestads Jubileumslopp från tolftespår bakom bilen.<br>Beartime tjänade över en miljon kronor under en säsong för första gången 2024 och största prischecken togs som trea i Paralympiatravets final på Åby.</p>



<p class="wp-block-paragraph"><strong>Startlista, Jarlsberg</strong><br>2.100 meter autostart, förstapris 100.000 norska kronor.<br><em>Häst (far) – Kusk</em></p>



<ol class="wp-block-list">
<li>Mc Burney (e. Credit Winner) – Magnus Teien Gundersen</li>



<li>King Okay (e. Maharajah) – Erlend Rennesvik</li>



<li>Cabron (e. Caballion) – Åsbjörn Tengsareid</li>



<li>Revenue Lavec (e. Revenue) – Lars Anvar Kolle</li>



<li>Kong du Dalm (e. Feeling Cash) – Henry Rorgemoen</li>



<li>I.D.Exceptional (e. El Diablo B.R.) – struken</li>



<li>Beartime (e. Pastor Stephen) – Ole Johan Östre</li>



<li>Stoletheshow (e. Dream Vacation) – Vidar Hop</li>



<li>Z.Boko (e. Zola Boko) – Eirik Höitomt</li>
</ol>



<p class="wp-block-paragraph"><a href="https://www.travsport.no/travbaner/bjerke-travbane/startlist/2025-01-18" target="_blank" rel="noreferrer noopener">Här är alla startlistor till Jarlsbergs tävlingar.</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/2022/08/alrajahonem220806adamstromstalltz-617x384.jpg" alt="" class="wp-image-337404"/><figcaption class="wp-element-caption">Alrajah One vid segern för Dexter Dunn i John Cashman Memorial. Foto Adam Ström/stalltz.se</figcaption></figure>



<p class="has-drop-cap wp-block-paragraph">5Åke Svanstedts tidigare världsstjärna <strong>Alrajah One</strong> (e. Maharajah-Mariu), 1.08.6*/$1.941.122, är på väg tillbaka till tävlingsbanan efter ha verkat i avel. Sin senaste start gjorde han den 25 november 2023 på Meadowlands.  <br>På söndag kvalar den nioårige hingsten för Marco Stefani på San Siro och det är Mauro Baroncini som tränat hästen. </p>



<p class="wp-block-paragraph">I slutet av 2023 återvände han till Italien efter åtta starter, fem segrar och 734.345 intjänade dollar i USA. Under USA-åren vann Alrajah One flera penningstinna löpningar; Maple Leaf Trot (C$530.000), John Cashman Memorial ($279.000), Spirit of Massachusetts ($250.000), Crawford Farms Open Trot ($147.000) och Allerage Farms ($135.000). </p>



<p class="wp-block-paragraph">Innan sejouren hos Åke Svanstedt tränades Maharajah-sonen av Alessandro Gocciadoro och i hans regi blev det inte bara seger i Derbyt, utan han vann också Gran Premio Citta di Padova, Gran Premio Continentale, Gran Premio Giuseppe Biasuzzi, Gran Premio d’Europa och Gran Premio Freccia d’Europa.</p>



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



<p class="has-drop-cap wp-block-paragraph">6Tre svenskfödda, flerfaldiga miljonärer finns med i eftermiddagens gulddivision i finska Tammerfors. Hannu Korpi står bakom två av dem, 1.08,3-travaren <strong>Hierro Boko</strong> (e. From Above) och <strong>Hector Sisu</strong> (e. Zola Boko), medan Reima Kuisla tränar <strong>Mandela Zon</strong> (e. Maharajah).</p>



<p class="wp-block-paragraph">Den sistnämnde var segerrikaste svenskfödde travare 2023 med 25 segrar (!) på 40 starter. Förra året fick han nöja sig med fyra vinster, men 2025 inleddes på bästa sätt med vinst i Seinäjoki.</p>



<p class="wp-block-paragraph"><strong>Startlista gulddivisionen, Tammerfors</strong><br>2.100 meter autostart, förstapris 6.000 euro.<br><em>Häst (far) – Kusk</em></p>



<ol class="wp-block-list">
<li>Condor Bar (e. Love You) – Santtu Raitala</li>



<li>Amazing Player (e. Quite Easy) – Jarmo Saarela</li>



<li>Kyle Web (e. Like A Prayer) – Henri Bollström</li>



<li>Mandela Zon (e. Maharajah) – Kari Rosimo</li>



<li>Hierro Boko (e. From Above) – Ilkka Korpi</li>



<li>Hotshot Luca (e. Dream Vacation) – Hannu Torvinen</li>



<li>Aragorn As (e. Ready Cash) – Jere Kiveinen</li>



<li>Sahara Sandstrom (e. Make It Happen) – Tino Paldan</li>



<li>Hector Sisu (e. Zola Boko) – Tuomas Pakkanen</li>
</ol>



<p class="wp-block-paragraph"><a href="https://heppa.hippos.fi/heppa/app?ct=YXBwbGljYXRpb24vcGRm&#038;d=dHJ1ZQ%3D%3D&#038;dr=&#038;f=b2hqZWxtYXRpZWRvdC5UXzE4LjAxLjIwMjUucGRm&#038;m=egkhIkPlIuVP8gBTv6tYXtNFULE%3D&#038;service=pdftmp" target="_blank" rel="noreferrer noopener">Här är alla startlistor till Tammerfors tävlingar.</a></p>



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



<p class="has-drop-cap wp-block-paragraph">7Nästan två tredjedelar – 14 av 23 travare – av hästarna i den digitala katalogen till Traveras traditionella lördagsauktion ikväll är starthästar. Toppnumret kan bli femårige <strong>Ferrara</strong> (e. Readly Express), 1.11,3ak/396.900 kr, som är lillebror till avelshingstarna <strong>Zola Boko</strong> och <strong>Yarrah Boko</strong>. </p>



<p class="wp-block-paragraph">Sex fölston finns i katalogen. Bland dessa fint stammade <strong>You to Optimize&#8217;em</strong> (e. Tactical Landing-Face’em), som tvingats avsluta tävlingskarriären efter fyraåringssäsongen på grund av skada.<br>Fölstoet <strong>Ester L.L.</strong> (e. Orlando Vici) bjuds ut till försäljning, liksom fem av hennes avkommor! Halvmiljonärskan <strong>Lina L.L.</strong> (e. S.J.’s Caviar) som fölstoprojekt, tre avkommor som starthästar och sedan tvåårige <strong>Rocky L.L.</strong> (e. Hard Livin). </p>



<p class="wp-block-paragraph">Tre nyblivna tvååringar tillhör unghästkategorin. Fäderna är Briskeby Philip, Hard Livin och Make It Happen.</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 hästarna som bjuds ut och följa budgivningen under kvällen.</a></p>

Fokustema
Sju nyheter vid sju
Läs senare
Jackpot för Lövgren på hemmaplan
Champion Lövgren visar vägen. Popparet bakom bästa jackpotspiken. Många blågula hopp på Vincennes. Världsstjärna gör comeback. Stoletheshow spränger ny miljonvall? Svenskfödda gräver guld i Finland.
Detta och mer i lördagens nyhetssvep.
Detta och mer i lördagens nyhetssvep.
