
<p class="has-drop-cap wp-block-paragraph">1Fyra raka segrar och utklassningsseger vid senaste Sverigebesöket i Bollnäs för fem veckor sedan. Vad ska kunna stoppa Merete Viksås tioåring <strong>Stumne Fyr</strong> (e. Joker Elden) i lördagens kallblodslopp i Bollnäs? Tongångarna från tränaren går i dur när Stumne Fyr ska plocka in 40 meters tillägg.</p>



<p class="wp-block-paragraph">Fast där framme – på startfållan – finns två starka svenska, sjuåriga utmanare. Jörgen Westholm plockar ut <strong>Guli Fantom</strong> (e. Bork Odin), som vunnit 20 av 52 starter.<br>– Det är bara att glömma senaste starten, han var het redan i värmningen. Nu är det en stor fordel att vi blivit nedstrukna till spår ett, men även om han är som allra bäst är jag inte säker på att han kan slå Stumne Fyr som imponerat mycket på mig. Taktiken bestämmer hästen själv, han trivs på fast bana och det det gäller att han håller sig på mattan, sade Jörgen Westholm till V65 Direkt.</p>



<p class="wp-block-paragraph">Ett annat blågult hopp på startfållan är Joakim Reiser-tränade <strong>Eld Tekno</strong> (e. Tekno Odin), som under unghäståren var finalist i norska Kriteriet och både svenska och norska Derbyt.<br>– Han känns väldigt fin och fortsatt bra som han varit. Vi var lite osäkra när vi slog på skorna om det skulle bli bra, men han är lika bra med skor som utan. Det känns som att han hittat rätt i sitt liv och vi hittat rätt. Vi har gett honom tiden och haft som mål att bli starkare och att han ska landa. Jag tycker att han har landat och tror att vi kommer att ha jätteroligt med honom och tävla ända upp till eliten, sade Joakim Reiser till V75 Direkt.</p>



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



<p class="has-drop-cap wp-block-paragraph">2 …men Sulkysports tipsexpert tror på den formstarke norske hästen, som har fyra raka segrar på svensk mark.<br><em>”Vi tror att Nordens just nu bästa kallblod räknar hem ytterligare en välbetald fullträff i Hälsingland och är något förvånade över att han inte är större favorit än vad han är i det här skedet när han jagar femte raka segern. Vi vill ha ”norsk bingo”!”</em></p>



<p class="wp-block-paragraph"><a href="https://sulkysport.se/spelstugan/v75-tips-20-januari/" target="_blank" rel="noreferrer noopener">––> Här är stora tipsgenomgången med analyser, spikar, drag och ranking av alla hästar på V75.</a></p>



<p class="wp-block-paragraph"><em>Vill du spela V75 tillsammans med Sulkysport finns följande alternativ:</em></p>



<p class="wp-block-paragraph"><a href="https://www.atg.se/andelskungen/spel/206687_V75_2024-01-20_12_5">Sulkysport Lilla V75 – 15 andelar á 75 kr/styck</a></p>



<p class="wp-block-paragraph"><a href="https://www.atg.se/andelskungen/spel/206688_V75_2024-01-20_12_5">Sulkysport V75 – 15 andelar á 150 kr/styck</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/2023/06/powerrb-617x333.jpg" alt="" class="wp-image-461972"/><figcaption class="wp-element-caption">Power och Robert Bergh startar på Vincennes idag. Foto Mathias Hedlund/Sulkysport</figcaption></figure>



<p class="has-drop-cap wp-block-paragraph">3Prix de Pardieu (€120.000) för fyraåriga, inhemska montéhästar är det högst doterade loppet vid dagens tävlingar på Vincennes (första start kl. 13.23) och det avgörs med svenskintresse. Tomas Malmqvist startar <strong>Kobalt du Vallon</strong> (e. Quaker Jet) som rids av Pierre Yves Verva, men hingsten förväntas inte utgöra favoritskaran i detta lopp där vinnaren belönas med 54.000 euro.</p>



<p class="wp-block-paragraph">Än mer intressant får dock Prix de Brest (€90.000) anses vara. <strong>Power</strong> (e. Googoo Gaagaa) jagar tillsammans med den forne Harper Hanovers-vinnare <strong>Diable de Vauvert</strong> (e. Prince d’Escape) från 25 meters tillägg och Robert Bergh nyttjar Dominik Locqueneux som kusk bakom Power denna dag.<br>Åbytränaren kör själv <strong>Pinto Bob</strong> (e. Maharajah) som inleder från startvolten liksom Daniel Redéns <strong>Kentucky River</strong> (e. Father Patrick), Björn Goops <strong>Betting Pacer</strong> (e. Maharajah) och Jean-Michel Bazires blågule <strong>Bordeaux S.</strong> (e. Orlando Vici).</p>



<p class="wp-block-paragraph">Lördagens sista svenskhopp på Vincennes syns i Prix Celine Leclercq (€46.000) för femåriga ston. Där låter Daniel Redén <strong>Mahala</strong> (e. Propulsion) göra sadeldebut och det sker med Eric Raffin som ryttare.</p>



<p class="wp-block-paragraph">Det tävlas även på Lyon La Soie (första start kl. 17.17) och dit sänder Jarmo Niskanen <strong>Jockstrap</strong> (e. Prince Gede) för start i Prix du Parc de la Chartreuse (€23.000).</p>



<p class="wp-block-paragraph"><a href="https://sulkysport.se/trav-och-galopp/paris-vincennes-2024-01-20/" target="_blank" rel="noreferrer noopener">Här kan du ta del av dagens startlistor till tävlingarna på Vincennes.</a></p>



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



<p class="has-drop-cap wp-block-paragraph">4Ett par dagar in på 2024 kom beskedet att Stig H Johansson lämnade in tränarlicensen efter en sagolik karriär. När mångåriga hemmabanan Solvalla har stortävlingar den 3 februari med Margaretas Tidiga Unghästserie och STL-finaler kommer Solvallas 29-faldige kuskchampion att stå i centrum. Det berättar Solvalla i ett pressmeddelande.<br><em>”Vi kommer se tillbaka på en makalös karriär, minnas storloppssegrar och topphästar samt givetvis hylla Stig H Johansson”, </em>skriver Solvalla.</p>



<p class="wp-block-paragraph">Stig H Johansson blev Solvallachampion första gången 1975. Sedan vann han även 1977 innan det blev en 27 år lång segersvit som inleddes 1979 och avslutades 2005. Samma år avslutade Stig H sin kuskkarriär på allvar, även om det blev några gästspel senare år.</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/11callmethebreeze-617x333.jpg" alt="" class="wp-image-308380"/><figcaption class="wp-element-caption">Callmethebreeze och Andrea Guzzinati vid seger i Fyraåringseliten. Foto Mathias Hedlund/Sulkysport</figcaption></figure>



<p class="has-drop-cap wp-block-paragraph">5Italienske topptravaren <strong>Callmethebreeze</strong> (e. Trixton) som vann Fyraåringseliten på Solvalla debuterar på australisk mark idag för Anton Golino i The Knight Pistol ($50.000)i Ballarat. Callmethebreeze har inte startat sedan 15 juli i Prix de Washington och där slutade femma på 1.09,9 i ett lopp som vanns av Etonnant på 1.09,3a/1.609 meter. </p>



<p class="wp-block-paragraph">Han ställs mot segermaskinen och Elitloppsstartande <strong>Just Believe</strong> (e. Orlando Vici), som vunnit sina fem starter i Australien sedan han återvände från Europaäventyret. Närmast kommer han från finalvinst i Inter Dominion Trotting Championship ($265.000) i mitten på december. </p>



<p class="wp-block-paragraph"><strong>The Knight Pistol ($50.000), 2.200 meter, autostart:</strong><br><em>Häst (far) – Kusk</em></p>



<ol class="wp-block-list">
<li>Mufasa Metro (e. Father Patrick) – John Justice</li>



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



<li>Callmethebreeze (e. Trixton) – Nathan Jack</li>



<li>Visionary (e. Orlando Vici) – David Moran</li>



<li>Hammers Law (e. Lawman) – Anthony Butt</li>



<li>Just Believe (e. Orlando Vici) – Greg Sugars</li>



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



<li>Im Ready Jet (e. Quaker Jet) – Kate Gath</li>



<li>Keayang Ignite (e. Angus Hall) – Jason Lee </li>



<li>Arcee Phoenix (e. Trixton) – Chris Svanosio</li>



<li>Travel Bug (e. Dream Vacation) – James Herbertson</li>



<li>Sleepee (e. Dejarmbro) – Josh Duggan</li>
</ol>



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



<p class="has-drop-cap wp-block-paragraph">6Några riktigt meriterade fölston finns bland de 32 hästar som bjuds ut på kvällens internetauktion hos Travera. <strong>Fly the World</strong> (född 2010 e. Juliano Star-Night Mare E.), 1.11,6ak/1.873.849 kr, tillhörde kullens främsta ston med seger i Guldstoet och Oaksförsök samt finalplats i Stochampionatet som unghäst. I aveln har hon två avkommor i startbar ålder, där Flys Popcorn vunnit två lopp.<br><strong>Julia Pellini</strong> (född 2013 e. Yankee Glide-Jullan), 1.10,8ak/1.420.818 kr, slutade tävla på senhösten 2022 och är inte dräktig.</p>



<p class="wp-block-paragraph">Totalt finns 13 fölston, 16 starthästar, tre tvååring och betäckningsrätter för 2024 i Bird Parker, Father Patrick och Six Pack till försäljning.</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>



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



<p class="has-drop-cap wp-block-paragraph">717 starter, sex segrar och över 2,8 miljoner norska kronor i prispengar blev den fina utdelningen för Frode Hamres elithäst <strong>Stoletheshow</strong> (e. Dream Vacation), som ägs i Sverige av Global Glide AB (Süleyman Yüksel). Nu är mångmiljonären redo för sin åttonde säsong på tävlingsbanan – han debuterade redan som tvååring med vinst i Torben Hovgaards regi och vann året efter Noirskt Travkriterium i träning hos Marcus Lindgren.</p>



<p class="wp-block-paragraph">Sedan slutet av 2021 har Frode Hamre stått för träningen och Stolethechow har varit en flitig gäst i de större sammanhangen, där segrarna i Oslo Grand Prix och Finlandia-Ajo sticker ut.<br>Stoletheshow har varit igång i stort sett utan uppehåll sedan i mars och startade senast i gulddivisionsfinalen på Solvalla annandag jul. </p>



<p class="wp-block-paragraph">Inga svenska tränare gör resan till Bjerke.</p>



<p class="wp-block-paragraph"><strong>Startlista gulddivisionen, 2.100 meter autostart:</strong><br><em>Häst (far) – Kusk</em></p>



<ol class="wp-block-list">
<li>Dream Builder (e. Joke Face) – Eirik Höitomt</li>



<li>First One Diamond (e. Ens Snapshot) – Marcus Totland Aadland</li>



<li>Charleston Volo (e. Classic Photo) – Per Oleg Midtfjeld</li>



<li>Skate Trix (e. Trixton) – Magnus Teien Gundersen</li>



<li>Always On Time (e. Revenue) – Tom Erik Solberg</li>



<li>Evening Quick (e. Magnificient Rodney) – Vemund Madsen Drolsum</li>



<li>Stoletheshow (e. Dream Vacation) – Frode Hamre</li>



<li>Miss Pepper (e. Quite Easy) – Åsbjörn Tengsareid</li>
</ol>



<p class="wp-block-paragraph"><a href="https://www.travsport.no/travbaner/bjerke-travbane/DownloadPdf/?location=BJ_20240120_Baneprogram.pdf&#038;epsremainingpath=" target="_blank" rel="noreferrer noopener">Här är startlistorna till Bjerkes tävlingar i eftermiddag.</a></p>

Fokustema
Morgonsvepet
Läs senare
De utmanar norska storfavoriten
Kallblod i centrum i Bollnäs. Bergh väljer bort Power på Vincennes. Då hyllas Sig H på Solvalla. Elitloppshästar tävlar både i Australien och Norge. Vassa ston säljs på auktion.
Detta och mer i lördagens ”Sju nyheter vid sju”.
Detta och mer i lördagens ”Sju nyheter vid sju”.
