
<p class="has-drop-cap">1Dubbeljackpot och nästan 29 miljoner kronor extra i sjurättspotten är det som väntar i eftermiddagens V75-omgång som avgörs på norska huvudstadsbanan Bjerke (första start 14.45). Omgångens största favorit blir Frode Hamre-tränade <strong>Stoletheshow</strong> (e. Dream Vacation), som är ägd i Sverige av Süleyman Yüksel (Global Glide AB, Skövde), i gulddivisionen som hyllar en av Norges allra främsta genom tiderna: Gunnar Eggen.</p>



<p>Efter femteplatsen i guldfinalen på Solvalla annandag jul har Stoletheshow joggat hem tre snabblopp hemma i Sverige. I eftermiddag är motståndet av annan kaliber. ”Vi väljer att gardera Stoletheshow (V75-6) nu när han möter helt annat motstånd än vad som varit fallet i årets tidigare starter”, skriver Sulkysports tipsexpert.<br>– <em>Stoletheshow verkar väldigt fin för dagen och är fräsch och nöjd. Spår ett är vad jag önskade mig. Normalt håller han ledningen och i den form han är i nu är det en toppsegerchans, även om jag har respekt för motståndarna. Han är inte lika bra som när han var som allra bäst, men tillräckligt bra för att vinna ett sådant lopp</em>, sade Frode Hamre till V65 Direkt.</p>



<p><strong>Kanske årsdebuterande stallkamraten Feydeau Seven (e. Redeo Josselyn) är ett hot?</strong><br>– Han är bra, men är lite tung i kroppen ännu och normalt ska han inte kunna slå Stoletheshow, sade Frode.</p>



<p>Hur ska man vinna miljonerna? <a href="https://sulkysport.se/spelstugan/v75-tips-bjerke-13-mars/" target="_blank" rel="noreferrer noopener">Här är Sulkysports stora tipsgenomgång med analyser, spikar, drag, spetsbud och ranking av alla hästar.</a></p>



<p><em>Vill du spela V75 tillsammans med Sulkysport finns följande alternativ:</em></p>



<p><a href="https://www.atg.se/andelskungen/spel/206687_V75_2024-03-16_78_5" class="">Sulkysport Lilla V75 – 15 andelar á 75 kr/styck</a></p>



<p><a href="https://www.atg.se/andelskungen/spel/206688_V75_2024-03-16_78_5" class="">Sulkysport V75 – 15 andelar á 150 kr/styck</a></p>



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



<p class="has-drop-cap">2En riktig kallblodsklassiker tar plats på Bjerkes V75-omgång i eftermiddag. Jacob Meyers Pokal kördes för första gången 1896 och hästar som vunnit loppet tidigare får inte vara med. Med undantag av fyra år under tidigt 1900-tal har ”Meyern” körts varje år fram till 2020, då loppet ställdes in helt och hållet på grund av pandemin.</p>



<p>En svensktränad häst – Ola Åsebös <strong>Soldhöjdens Drake </strong>(e. Lome Brage) – utmanar tio norska kallblod i kamp om segern och 200.000 kronor i förstapris. Loppet avgörs över medeldistans – och med voltstart, där Soldhöjdens Drake dragit andraspår och ställs mot tre starka, helnorska kort.</p>



<p>Merete Viksås-tränade<strong> Stumne Fyr</strong> (e. Joker Elden) har haft toppform hur länge som helst och vann Alf Jonssons lopp på Bergsåker för en månad sedan med nio längder. Då som nu inledde Stumne Fyr från bakspår.</p>



<p>Öystein Tjomsland mönstrar en högintressant duon, som båda gör årsdebut. <strong>Tangen Bork</strong> (e. Bork Odin) hade en stark säsong ifjol med 1,8 miljoner insprunget, medan <strong>Grislefaksen G.L.</strong> (e. Järvsöfaks) fick sitt genombrott i den äldre eliten ifjol som nioåring och bland annat vann Nordiskt Mästerskap i finska Åbo.<br>– <em>De har tränat på bra i vinter med styrketräning i december-januari. Sedan har det varit fartträning de senaste veckorna och vi haft väldigt fina träningsförhållanden. De är bra förberedda och gick ett snabbjobb tillsammans förra veckan över 2.300 meter i 1.24-fart. Båda kändes starka, jag vill inte sätta någon före den andra och båda bra nog för att vinna</em>, sade Öystein Tjomsland till V65 Direkt och fortsatte:<br>– <em>Grislefaksen är ojämn i voltstart och det är ett litet minus, men om han har en bra dag kan han öppna bra. Klarar han att hålla upp ledningen stiger hans chanser, men Tangen Bork är en mer speedig häst som kan få rätta loppet från bakspår. Med all respekt för motståndarna så har vi de två bästa hästarna.</em></p>



<h2 class="wp-block-heading">Svenskfödda vinnare i Jacob Meyers Pokallöp:</h2>



<ul class="wp-block-list">
<li>1995 <strong>Verner</strong> (e. Slogum Tron) – Jim Frick (Ulla Fredlund) – 1.26,6</li>



<li>2001 <strong>Järvsöfaks</strong> (e. Trollfaks) – Jan-Olov Persson – 1.25,2</li>



<li>2003 <strong>Nordgubben</strong> (e. Braute) – Kenneth Karlsson – 1.27,4</li>



<li>2007 <strong>Fakse</strong> (e. Järvsöfaks) – Jan-Olov Persson – 1.24,9</li>



<li>2013 <strong>Faksen J:r </strong>(e. Järvsöfaks) – Jan Ove Olsen (Jan-Olov Persson) – 1.25,0</li>



<li>2016 <strong>Månprinsen A.M.</strong> (e. Svall Ivar) – Gunnar Melander – 1.25,4</li>



<li>2021 <strong>Månlykke A.M.</strong> (e. Månprinsen A.M. – Gunnar Melander – 1.23,3</li>
</ul>



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



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



<p class="has-drop-cap">3Björn Goop och Jorma Kontio finns samtliga representerade när den årliga kuskmatchen Arctic Challenge idag avgörs i finska Rovaniemi (första start kl. 14.11).</p>



<p>Från utlandet gästar även irländske Sean Kean i denna kuskmatch som avgörs över tre lopp, men såväl Goop som Kontio har även ”bonusstyrningar” under tävlingsdagen.</p>



<p>Björn Goop och Jorma Kontio kuskar i nio av tävlingsdagens tolv lopp.</p>



<p>I högsta klassen för varmblod är åtta av deltagarna svenskfödda och ytterligare en har blågul koppling då Hanna Olofsson prövar lyckan med franskfödde <strong>Humble Stance </strong>(e. Repeat Love) som vunnit tre av årets fem starter.</p>



<p><strong>Startlista Gulddivisionen</strong><br><em>2.100 meter autostart, förstapris: 7.000 euro</em></p>



<ol class="wp-block-list">
<li>Adde S.H. – Jorma Kontio</li>



<li>No Limit Royalty – Santtu Raitala</li>



<li>Kurri Jari Boko – Iikka Nurmonen</li>



<li>Double Trouble E.P. – Jarmo Saarela</li>



<li>Humble Stance – Jenny Engfors (Hanna Olofsson)</li>



<li>Claude P.Hill – Ville Koivisto</li>



<li>Mr Golden Quick – Kari Alapekkala</li>



<li>Farzad Boko – Antti Ala-Rantala</li>



<li>Leader Brodde – Olli Koivunen</li>



<li>Anything For You – Nika Jokela</li>



<li>Shotproof – Maria Kurttila</li>



<li>Selmer I.H. – Hannu Torvinen (Bert Pettersson)</li>
</ol>



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



<p class="has-drop-cap">4Fyra franska travbanor arrangerar tävlingar denna lördag, men det är enbart i Reims (först start kl. 16.42) som det finns svenskintressen.</p>



<p>Där prövar Jarmo Niskanen lyckan med fyraårige <strong>Kito Turgot</strong> (e. Rolling d’Heripre) i Prix des Coquelicots (€21.000) som jagar första årssegern och det hägrar även för Ron Kuipers <strong>Idylle du Nord</strong> (e. Quaker Jet) i amatörloppet Prix des Roses (€6.000) där stoet körs av Ann Kristin Rasmussen.</p>



<figure class="wp-block-image aligncenter size-sulky-mellan2"><img src="https://sulkysport.se/wp-content/uploads/2020/01/jarmoniskanen-617x309.jpg" alt="" class="wp-image-59460"/><figcaption class="wp-element-caption">Jarmo Niskanen. Foto Mia Törnberg</figcaption></figure>



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



<p class="has-drop-cap">5Få deltagare, men urstarka toppnamn. Så kan man sammanfatta dagens fyraåringslopp Premio Pulpitum (€12.650) som avgörs på Capanelle-banan i den italienska huvudstaden Rom.</p>



<p>Fjolårets italienska derbytvåa <strong>Ector Francis </strong>(e. Nad Al Sheba) går upp i ringen mot <strong>Encierro</strong> (e. Tobin Kronos) som slutade fyra i samma lopp och det hela kryddas med start för Alessandro Gocciadoros<strong> Everything Bi</strong> (e. Varenne) som var trea i fjolårets Breeders Course-final bakom Ester degli Dei och Eros Jet.</p>



<p><strong>Startlista Premio Pulpitum</strong><br><em>1.640 meter autostart</em></p>



<ol class="wp-block-list">
<li>Ector Francis – Gaetano di Nardo</li>



<li>Encierro – Gaspare Lo Verde</li>



<li>Emerald Grif – Enrico Bellei</li>



<li>Everything Bi – Alessandro Gocciadoro</li>



<li>Elixia – Vincenzo Castiglia</li>



<li>Emily Lp – Roberto Vecchione</li>
</ol>



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



<p class="has-drop-cap">6Rick Ebbinge har räknat in ett nyförvärv från en Åbykollega. Från André Eklundhs stall kommer <strong>Uncle Töll </strong>(e. Beer Summit) 1.11,5ak/1.431.590 kr vars karriär hittills innehållit 15 segrar på 52 starter.</p>



<p>Den mest penningstinna togs år 2020 då hästen vann en Klass II-final med 220.000 kronor i segerpremie och året därpå räknade han hem Svensk Travsports Femåringsmonté med 100.000 kronor i segerpremie.</p>



<p>Fjolåret innehöll två segrar på nio starter och hästen har inte synts i tävlingssammanhang sedan början av juli.</p>



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



<p class="has-drop-cap">7Det är 25 objekt till salu på kvällens Travera-auktion och bland dem är <strong>Itso Sisu</strong> (e. Bold Eagle) 1.12,5am/613.300 kr den mest namnkunniga bland starthästar.</p>



<p>Markus Pihlström tränar den sexårige valacken som står med över 2.000 startpoäng och en 75.000 kronorsseger i resultatraden.</p>



<p>Face Time Bourbons avkommor fortsätter att &#8221;gå som tåget&#8221;. Under gårdagen hade han en övertygande treåringsvinnare på Åby då <strong>Magic In</strong> vann på 1.15,3/2.140 meter och ikväll finns möjligheten att klicka hem en livstids betäckningsrätt med den franska superhingsten.</p>

Fokustema
Morgonsvepet
Läs senare
Stjäl nån annan showen?
Om dagens STL-tävlingar på Bjerke, derbyhästar i kamp med Sverigebekant i Rom och så har Rick Ebbinge stärkt upp stallet med en miljonär. Om det och mycket annat går att läsa i dagens morgonsvep.
