<p>Vid fjolårets V75-omgång under Oslo Grand Prix-dagen stannade utdelningen på 1.297 kronor, men årets omgång ser möjligen ut att ha lite mer skrällpotential i sig.<br />
Med formsvaga toppar i kallblodsloppet, dåliga lägen för några av topparna i Europamatchen och lite frågetecken kring moralen på några av de mer betrodda i Stoeliten går det åtminstone att spekulera i att utdelning kan springa iväg en bit även om omgångens megalampa <strong>Zalie Gar</strong> (V75-3) sannolikt vinner.</p>
<h2>Måstestrecken</h2>
<ul>
<li>Stayerloppet (V75-1) är en öppen historia och vi regerar över att <strong>Stud Muffin</strong> blott är spelad på sex procent i skrivande stund. Nog för att Flemming Jensen ligger lågt, men vi vet sen gammalt att han inte lägger timmar på att studera motståndet utan här utgår han säkert ifrån att konkurrensen är stenhård eftersom det är en Oslo Grand Prix-dag. Det är den inte alls i det här loppet även om det finns dugliga toppar och såväl hästen som stallet (Jensens enda starthäst på Bjerke under lördagen vann) visar form. Given för oss!</li>
<li><strong>Roli Eld</strong> (V75-4) avslutade strålande i Elitkampen och det här loppet tycker. vi inte är lika bra. Det finns frågetecken för hur det kommer gestalta sig rent taktiskt för några av de som blir mer betrodda och det kan öppna upp för Roli Eld som närmat sig eliten för varje lopp han gått under våren.</li>
<li><strong>Viscarda Jet</strong> (V75-5) blev något av Elitloppshelgens &#8221;kommundrag&#8221;, men än så länge är hon helt bortglömd trots att Björn Goop svingar sig upp bakom stoet för första gången. Galoppen senast tog kusken på sig helt själv och normalt sett är hon inte alls osäker. Med Elite du Ruel borta ur startlistan har Viscarda Jet rygg på två startblixtar i Peace of Mind och Ultra Bright och här har Björn Goop alla möjligheter att hamna en bra bit fram direkt. Stoet slog riktiga toppar i Italien under fjolåret och tränarsonen Joseph Ruocco flaggar dessutom för att det kan bli jänkarvagn denna gång om Björn Goop så önskar.</li>
</ul>
<h2>Överstreckade</h2>
<ul>
<li><strong>Velocity de Vie</strong> (V75-1) kommer från seger och gjorde det absolut bra den dagen, men den här uppgifte är klart tuffare. Han har blandat och gett under våren och som favorit är han inget vi vill rygga fullt ut.</li>
<li>Det löste sig inte optimalt för <strong>Polara</strong> (V75-4) i Elitkampen, men vi är ändå lite skeptiska till om han är i lika bra form nu som när han vann det här loppet i fjol. Den finska stjärnan har inte sett lika vass ut i vårens starter &#8211; det har inte varit samma tryck i steget &#8211; och vi kan se honom förlora även från ledningen om han behövt bråka med landsmannen Josveis initialt.</li>
<li>Det råder ingen tvivel om att <strong>Heart of Steel</strong> (V75-6) är riktigt bra, men är han nödvändigtvis bättre än hästar som Alcoy, Vainqueur R.P. och Vincero&#8217; Gar? Nej, vi är inte så säkra på det och påminner om att han fått hållas i rätt så måttlig fart framme i tät i de två senaste starterna. Här är det upplagt för att det kommer se helt annorlunda ut. Det räcker bara att läsa Christophe Martens intervju med Alcoy nedan så förstår du vad vi menar&#8230;</li>
</ul>
<div class="factbox full ">
<div class="insidefactbox">
<div class="overflow">
<div class="height">
<div class="padding">
<div class="factvinjett">Fakta</div>
<h3 class="title">
									SPELFÖRSLAGET								</h3>
<div class="content">
<p>Kupong 1:<br />Avd 1: 11 Stud Muffin (2,13)<br />Avd 2: 1,6,7 (2,5)<br />Avd 3: 3 Zalie Gar (2,1)<br />Avd 4: 3,6,8 (4,9)<br />Avd 5: 2,3,6,7,10,11 (5,8)<br />Avd 6: 2,4,6,8,9 (11,7)<br />Avd 7: 2,9 (4,3)<br /><em>540 rader/270 kronor</em></p>
<p>Kupong 2<br />Avd 1: 1,2,3,5,7,9,10,13 (6,12)<br />Avd 2: 1,6,7 (2,5)<br />Avd 3: 3 Zalie Gar (2,1)<br />Avd 4: 6 Roli Eld (4,9)<br />Avd 5: 2,3,6,7,10,11 (5,8)<br />Avd 6: 2,4,6,8,9 (11,7)<br />Avd 7: 2,9 (4,3)<br /><em>1.440 rader/720 kronor</em></p>
<p>Kupong 3<br />Avd 1: 1,2,3,5,7,9,10,13 (6,12)<br />Avd 2: 1,6,7 (2,5)<br />Avd 3: 3 Zalie Gar (2,1)<br />Avd 4: 3,6,8 (4,9)<br />Avd 5: 10 Viscarda Jet (5,8)<br />Avd 6: 2,4,6,8,9 (11,7)<br />Avd 7: 2,9 (4,3)<br /><em>720 rader/360 kronor</em></p>
<p><strong>Totalt:</strong> 2700 rader/1.350 kronor</p>
</p></div>
</p></div>
</p></div>
</p></div>
</p></div>
</p></div>
<ul>
<li><em><a href="https://sulkysport.se/wp-content/uploads/2019/06/2019060820190612.pdf">Startlistor Bjerke söndag 9 juni</a></em></li>
</ul>
<p>I samarbete med norska facktidningen Trav og-Galoppnytt kan Sulkysport presentera intervjuer på V75-hästarna.</p>
<h2>V75-1</h2>
<p>– <strong>Captain Morgan</strong> (1) visade bra form vid segerloppet senast. Det är tuffa motståndare här, men han står fint till och skulle det lösa sig är han inte utan chans här heller, säger Anders Lundström Wolden.<br />
– <strong>Outstanding O.</strong> (2) satt perfekt till i rygg på ledaren senast i Harper Hanovers lopp, men blev dragen bakåt då ledaren stannade. Han hade varit med bland de tre främsta med bättre flyt. Hästen tränar väldigt fint och möter enklare sällskap nu. Plan A är att ta ledningen och stanna kvar där så länge det går. Ska streckas, säger Moeten Haugland.<br />
– <strong>Red Bar</strong> (3) blev det norskt huvudlag på den här gången. Jag är osäker på hur han är i voltstart, men om han håller sig lugn är han bra nog och i tillräcklig form för att duga, säger Ole Johan Östre.<br />
– <strong>Soros Kronos</strong> (4) är i god form, men det är hårt emot denna gång så en peng är målsättningen, säger Hans Christian Holm.<br />
– <strong>Bear Hope</strong> (5) ser fin ut i träningen och från femtespår tror jag att han kan öppna bra. Kommer han till ledningen är han inte helt borta trots att det är tuffa hästar på tillägg, säger Anton Sverre i Björn Goops stall.</p>
<blockquote><p>Kommer han till ledningen är han inte helt borta</p></blockquote>
<p>– <strong>Bleeding Heart</strong> (6) möter tuffa hästar så en premie är målsättningen, säger Lars Anvar Kolle.<br />
– <strong>Whatsoflying S.S.</strong> (7) var väldigt bra senast med full spänst över mål. Distansen ska passa, men motståndet är tufft. Skulle det klaffa kan han vara med bland de tre främsta, säger Jan Erik Isaksen.<br />
– <strong>Double Spin</strong> (8) verkar vara i väldigt god form, men han står tufft inne i loppet här så normalt sett får vi var anöjda om han tjänar en peng, säger Eirik Høitomt.<br />
– <strong>N.Y.Coeur de Soleil</strong> (9) var ”knallgo” senast på Solvalla. Nu är det dubbelt så lång distans, men han är allround. Nu blir det vanlig sulky och norskt huvudlag. Med rätt lopp är han en av flera som gör upp om segern i ett väldigt öppet lopp, säger Magnus Teien Gundersen.<br />
– <strong>Volocity de Vie</strong> (10) behöver lång distans för att komma till sin rätt och han vann väldigt lätt utan att vara bottnad senast. Han kom då till ledningen mitt i loppet. Det är rätt sorts uppgift igen, men motståndet kanske är hårdare den här gången än senast. Planen är att han ska fortsätta på barfotabalans om banförhållandena passar för det, säger Clas-Göran Björkroth i Timo Nurmos stall.<br />
– <strong>Stud Muffin</strong> (11) gick långa lopp och är i bra form. Jag känner inte till alla konkurrenter, men jag tror inte på någon segerchans. Han går barfota som vanligt, säger Flemming Jensen.<br />
– <strong>Blumberg Delo</strong> (12) har jag haft i tre månader. Formen är väldigt fin. Han var inte långt ifrån vinnaren i loppet den 4 maj, men blev tufft diskvalificerad. Hästen är väldigt stark och jag tror han kan dyka upp bland de tre främsta. Inga ändringar, säger Arnold Mollema.<br />
– <strong>Ochongo Face</strong> (13) gick ett starkt lopp senast i Köpenhamn och därefter har vi siktat in oss mot detta. Han tränar bra och även om det är några tuffa konkurrenter med så tycker jag uppgiften ser passande. Avsaknaden av körspö kan vara ett minus, men vi får vässa upp honom lite i träningen så ska det nog gå bra. Inga ändringar, säger Fredrik Palm.</p>
<h2>V75-2</h2>
<p>– <strong>Patent Leather</strong> (1) blev det fel för på Solvalla. Både hästen och kusken gav upp när det blev som det blev. Hästen är bra och ska räknas med segerchans även om han inte kan svara ut Samo Different Day från start. Samma utrustning som senast, säger Frode Hamre.<br />
– <strong>Samo Different Day</strong> (2) är behandlad och har stor kapacitet. Han tränar bra och står inte tillbaka för Patent Leather, men vi är lite osäkra efter att han galopperat i två starter för oss. Hästen är väldigt startsnabb och ska räknas som en outsider, säger Frode Hamre.<br />
– <strong>L.A.’s Magic Moment</strong> (3) jagar banrekordet för norskfödda fyraåringar på 1.10,9 vilket jag tror att han kan klara av. Han fick problem med halsen nyligen och fick strykas inför en tilltänkt start. Att vara med bland de tre främsta blir tufft, säger Anders Lundström Wolden.<br />
– <strong>Zelig Kronos</strong> (5) hoppas jag har gått framåt med de två senaste loppen han gjort. Han har varit kvar i Sverige hela tiden och jag tror det blir helstängt huvudlag nu, säger Pietro Gubellini.<br />
– <strong>Mister F. Daag</strong> (6) vann påett väldigt fint sätt i Köpenhamn. Han är inte någon startraket, men kan göra mycket själv i loppen. Inga ändringar är planerade och jag tror att kommer göra en stark insats igen, säger Paul Hagoort.<br />
– <strong>Missle Hill</strong> (7) var fin senast i Fyraåringseliten och det var kul att se att han tagit Vermo-loppet på rätt sätt. Känslan är att han gått framåt ännu mer till den här starten. Det här är en kapabel häst som jag tror mycket på i framtiden och han ska kunna gå exakt balanserad som senast, säger Daniel Redén.<br />
– <strong>Park View</strong> (8) blev det helt fel för på Solvalla med det väder och den bana som var den dagen. Det loppet kan man glömma. Jag tror han kan springa en hög 1.10-tid på en bra dag, men möjligheternna försvann i takt med spåret. Härifrån handlar det om bästa möjliga premie, säger Erik Killingmo.</p>
<h2>V75-3</h2>
<p>– <strong>Racing Ribb</strong> (1) gick barfota runt om för första gången senast och lade inte riktigt ner sig i grejorna från start då, och det blev ännu knepigare av att han hade andraspår. Efter galoppen kändes han bra. När vi nu har innerspår väljer jag nog nog att ha lätta framskor på honom för att hästen ska känna sig stabil och då kan jag ladda ordentligt. Håller vi ledningen är det vinstchans, för hästen är i toppform, säger Adrian Kolgjini.<br />
– <strong>Mellby Frodo</strong> (2) satt fast senast mot tuffa hästar. Det är hårt motstånd även här, men hästen är bra själv. Han ska räknas i tätstriden från ett perfekt spår, säger Kristian Malmin.<br />
– <strong>Zalie Gar</strong> (3) är en riktigt bra häst och allt har varit som det ska med henne efter senast. Hon tävlar alltid med skor och känslan är att hon har bra chans här utan att jag har full koll på motståndet, säger Alessandro Gocciadoro.<br />
– <strong>Ofelia O.E.</strong> (4) krånglade med huvudet och galopperade innan start senast. Hon gick vad hon skulle efteråt och det var tråkigt att hon agerade opålitligt igen efter en lång period där hon skött sig. Nu får hon möta hingstar och då slår hon ur underläge. Inga ändringar, säger Peter Untersteiner.</p>
<figure id="attachment_44954" aria-describedby="caption-attachment-44954" style="width: 617px" class="wp-caption alignright"><img class="size-sulky-mellan2 wp-image-44954" src="https://sulkysport.se/wp-content/uploads/2019/05/zaliegar-617x309.jpg" alt="" width="617" height="309" /><figcaption id="caption-attachment-44954" class="wp-caption-text">Zalie Gar var förkrossande överlägsen i Fyraåringseliten för ston. Nu ska Rene&#8217; Legati försöka kvala in toppstoet till Klass I-finalen i Sundbyholm. Foto Mia Törnberg</figcaption></figure>
<p>– <strong>Down and Dirty</strong> (5) håller väldigt fin form. Han blev fast på Solvalla och gick i mål med allt sparat. Nu stöter vi på några väldigt bra hästar med Zalie Gar i spetsen. Kanske att han kan vara trea med maxflyt, säger Tor Arne Eggen.<br />
– <strong>Humble Hill</strong> (6) är behandlad och har tränat på bra en längre period. Han står chansartat till mot tuffa hästar så det blir inte lätt att vinna, men en outsider kan han vara på sin fina kapacitet, säger Frode Hamre.<br />
– <strong>Beyblade</strong> (7) blev sliten i comebacken efter att varit ifrån längre. Detta är en bra häst som var med i derbyt för två år sen. Han har gått framåt med loppet i kroppen, men härifrån är det en peng som gäller, säger Flemming Jensen.<br />
– <strong>Listas Manboy</strong> (8) står omöjligt till mot bra hästar så jag ligger lågt, säger Knud Mønster.<br />
– <strong>Creek’s Survive</strong> (9) blir bättre och bättre för varje start och ser fin ut i träningen. Jag räknar med att han kan tävla på samma nivå som när han gick 1.11,7 i fjol. Hästen är rask iväg så spåret passar bra med rygg på startsnabba hästar. Jag har ambitioner och kör utan skor precis som tidigare, säger Bjørn Garberg.<br />
–<strong> L’Amour Bonanza</strong> (10) blir det lite långt för mellan loppen nu, men han tränar bra och jag har siktat mot det här loppet. Spåret passar, men konkurrensen är tuff. Han kan vara med bland de tre främsta. Lättas i balansen nu, säger Sven Olav Weberg.<br />
– <strong>Rajah Silvio</strong> (12) tog Gävleloppet på ett bra sätt. Här jagar han nya startpoäng för att komma med i Klass I-finalen och det utesluter jag inte alls att han kan ordna trots startspåret. Det blir barfota runt om och jänkarvagn på nytt, säger Anton Sverre i Björn Goops stall.</p>
<h2>V75-4</h2>
<p>– <strong>Ådne Odin</strong> (1) har känts förbättrad efter senaste starten. Han var lite tunt jobbad inför det loppet. Från ett fint spår ska han kunna få en fin position eftersom han är startsnabb. Han kan klara av en placering bland de tre främsta med klaff. Vi kommer inte göra några väsentliga ändringar, säger Veronika Bugge.<br />
– <strong>Smedheim Solan</strong> (2) avslutade bra senast på Bergsåker. Nu har han äntligen ett bra utgångsläge när han möter eliten och jag tror att han kommer göra ett bra lopp på söndag för det känns som han är i det bästa skick han varit under tiden i min regi. Inga ändringar, säger Jan-Olov Persson.<br />
– <strong>Polara</strong> (3) har vunnit spårlottningen. Det är ett stort plus om han kan tävla utan skor. Han ska ha bra chans att nå ledningen och därifrån är han väldigt bra på att försvara sig‚ säger Trav og Galoppnytts finska medarbetare Martti-Ala Seppälä.<br />
– <strong>Hallin Faxen</strong> (4) visade bra takter senast och är en häst med stor kapacitet. Han kommer att göra ett bra lopp, men slår normalt sett inte de bästa om de löper upp till sin normala nivå. En fin peng kan han däremot få med sig, säger Olav Mikkelborg.<br />
– <strong>Valle Mattis</strong> (5) var vi väldigt nöjda med på Solvalla där jag tycker han gick ett riktigt starkt lopp. Allt har varit bra med honom efter det loppet så med klaff på loppet kan han vara med bland de tre främsta, säger Heidi Moen.<br />
– <strong>Roli Eld</strong> (6) gick strålande de sista 300 meterna på Solvalla och det här loppet är billigare. Precis som den dagen på Solvalla så ska han gå barfota fram. Han når inte ledningen, men ska kunna få en bra position. Jag tycker att han har vinstchans, säger Frode Hamre.</p>
<blockquote><p>Det här loppet är billigare</p></blockquote>
<p>– <strong>Odd Herakles</strong> (7) tränar bättre än någonsin. Senast fick han ett tufft lopp samtidigt som han blev hovöm. Nu behöver han åtminstone gå m ed bakskor. Det blir en offensiv satsning, men spåret blev så dåligt att möjligheterna har reducerats, säger Lars O. Romtveit.<br />
– <strong>Josveis</strong> (8) var bra på Solvalla. Det blir tufft att komma till tät nu när han har Odd Herakles och Polara innanför sig och från dödens tror jag inte han vinner. Skulle likväl komma förbi dem och nå ledningen är han med i segerstriden, säger Trav og Galoppnytts finska medarbetare Martti-Ala Seppälä.<br />
– <strong>Ulsrud Tea</strong> (9) håller alltid bra form. Spåret drar ner möjligheterna då jag tror att hon har dåliga startryggar. Hon behöver tur och jag tror det blir tufft att vinna, säger Ove Kenneth Karlsen.<br />
– <strong>Torpa Nicklas</strong> (10) öppnade i 1.18-tempo i Sken senast efter att blivit hetsig i ledningen. Han håller väldigt fin form och är tillräckligt snabb i benen för att kunna vara med dem. Härifrån får vi hoppas på en peng och att han kan gå ett rekord på en 1.20-tid, säger Odd Arne Sagholen.</p>
<h2>V75-5</h2>
<figure id="attachment_22314" aria-describedby="caption-attachment-22314" style="width: 617px" class="wp-caption alignright"><img class="size-sulky-mellan2 wp-image-22314" src="https://sulkysport.se/wp-content/uploads/2018/04/ultrabright-617x1036.jpg" alt="" width="617" height="1036" /><figcaption id="caption-attachment-22314" class="wp-caption-text">Fredrik Perssons Ultra Bright ska starta på Bjerke. Foto: Mia Törnberg/Sulkysport</figcaption></figure>
<p>– <strong>Umaticaya</strong> (1) var inte som bäst senast. Hon blir kraftigt överflyglad från ett sådant här läge och det är bara en premie som gäller nu, säger Frode Hamre.<br />
– <strong>Calina</strong> (2) gick troligen sitt bästa lopp i karriären senast. Jag kör allt jag kan från start, men tror inte vi kan hålla ut Peace of Mind. Barfota, helstängt huvudlag samt jänkarvagn. Hon kan vinna om det klaffar; såbra är hon, säger Frode Hamre.<br />
– <strong>Peace of Mind</strong> (3) gick riktigt bra senast och jag tror att hon kan ta spets här. Hon är i fin form och det är inte omöjligt att hon leder hela vägen. Barfota runt om, säger Alessandro Gocciadoro.<br />
– <strong>Ultra Bright</strong> (5) kändes väldigt fin i travet senaste men däremot var hon lite tung och seg. Jag vill ge henne ett lopp till innan Stoeliten hemma i Kalmar den 23 juni och tänker därför spara hovarna nu och köra med lätta skor. Jag laddar och hoppas och komma ner bakom Peace of Mind, säger Fredrik Persson.<br />
– <strong>Gina Schermer</strong> (6) var väldigt bra senast, men det här är ett tufft lopp. De kommer dock inte springa ifrån henne och hon kan vara med bland de tre-fyra främsta. Hon karn inte varit lika snabb bakom bilen i Sverige som i till exempel Frankrike, säger Rick Ebbinge.<br />
– <strong>Shadow Gar</strong> (7) är allt bara väl med efter senast och hon gjorde det bra då efter att ha fått trava i dödens och dra fram Mellby Free. Det var längesedan vi ändrade något på henne och gör inga nu heller, säger Jerry Riordan.<br />
– <strong>Odessa Celeber</strong> (8) är under utveckling, men fick trist läge i väldigt tufft sällskap. Hon måste ha tur härifrån och kommer tävla precis som senast, säger Roger Walmann.<br />
– <strong>Madelen L.T.C. </strong>(9) har fått ett bra spår och formen är god, men här möter hon hästar som jag tror blir för tuffa att matcha. Kan hon vara med bland de fem främsta har hon gjort det bra, säger Eirik Høitomt.<br />
– <strong>Viscarda Jet</strong> (10) kom upp för tidigt bakom vingen senast och blev stressad när de andra hästarna fyllde på bakifrån. Därav blev det galopp och Jorma tog på sig det. Hon flög fram över upploppet innan och känns strålande i träningen så jag tror absolut att hon duger fint även mot de bästa stona i Norden. Nu blir det skor, men det är ingen fara och med största sannolikhet fortsätter vi med vanlig vagn, säger tränarsonen Joseph Ruocco.<br />
– <strong>Hillary Queen</strong> (11) var mycket bra på Vincennes. Bakspår och sprinterdistans drar ner förhoppningarna. Det måste bli överpace för att hon ska kunna komma in i loppet, men hon är stark och kan komma i in imatchen om så blir fallet. Jag tror inte vi gör några ändringar, säger Paul Hagoort.<br />
– <strong>Normandie Royal</strong> (12) är tillbaka i form och gjorde ett topplopp senast, men från detta startspår är det iskallt. Det är en peng som gäller, säger Frode Hamre.</p>
<h2>V75-6</h2>
<p>– <strong>Elvis d’Evron</strong> (1) har utvecklat sig mycket och är i bra form. Han klarar inte av att hålla ledningen, men jag tror han kommer göra ett bra lopp. Han matchar inte Alcoy, men kan vara trea-fyra, säger Gerard Forni.<br />
– <strong>Alcoy</strong> (2) gjorde sitt bästa lopp i karriären senast och är otroligt bra! Jag kommer inte ladda från start, men kan köra när jag vill efter det för han tål att göra jobb. Det blir barfota fram igen och avsaknaden av körspö kommer inte påverka honom. Jag har respekt förmotståndet, men tror inte att någon är bättre än min häst, säger Christophe Martens.</p>
<blockquote><p>&#8221;Tror inte att någon är bättre än min häst&#8221;</p></blockquote>
<p>– <strong>Casino Gardenia</strong> (4) har inte varit hundraprocentig i de senaste starterna och jag tror han kommer vara mycket bättre nu. Det är en bra hästsom bör räknas, säger Knud Mönster.<br />
– <strong>Dibaba</strong> (4) valde jag att gå ut mot hingstarna med. Hon duger fartmässigt och galopprisken är lika stor här som det är i stoloppet där man kör om 100.000 kronor. Här är det 300.000 och hon har känts jättefin efter senast. Vi gör inga ändringar och jag hoppas på en fin prestation, säger Roger Walmann.<br />
– <strong>Heart Of Steel</strong> (6) har varit fin i två raka spetssegrar. Det har varit tacksamma lopp för honom, men han har vunnit på bra vis och känns fortsatt fin i träningen. Hästen gör alltid sitt oavsett löpningsförlopp och vi fortsätter med barfota runt om, säger Peter Untersteiner.<br />
– <strong>Hambo Transs R.</strong> (7) fick ett preparélopp senast i Billund. Det gick väldigt fort till slut och hästen visade att han är i bra form. Han är rask iväg, men spåret är chansartat. Inga ändringar, säger Paul Hagoort.<br />
– <strong>Vainqueur R.P.</strong> (8) har sett fin ut här hemma i träningen och det råder ingen tvivel om att det är en klasshäst. Vi har en stark tro på att han kommer göra ett bra lopp, men från åttondespår kommer det krävas en del tur hur bra hästen än är, säger Anton Sverre i Björn Goops stall.<br />
–<strong> Vincero’ Gar</strong> (9) gör det alltid bra och det kan vara nyttigt för honom med ett lopp i ryggar. Om banan är fin kommer han att tävla barfota runt om, säger Alessandro Gocciadoro.<br />
– <strong>Tsunami Diamant</strong> (10) har ännu en gång fått bakspår. Hästen är i form och tränar bara bättre och bättre. Mina två hästar är jämngoda och positionerna kommer avgöra de två emellan. Inga ändringar, säger Paul Hagoort.<br />
– <strong>Speedy Face</strong> (11) har känts jättebra i jobben inför denna säsong och han kommer att få ett bra år. Senast slog han bra hästar lätt i Lyons lopp för femåringar. Jag valde mellan detta lopp och Jämtlands Stora Pris och med facit i hand hade det nog varit bättre att välja Östersund. Det är tufft motstånd och svårt läge här och jag får hoppas på att det blir överpace och att vi får ett bra lopp i draget. Vi siktar på att köra barfota runt om, säger Adrian Kolgjini.</p>
<h2>V75-7</h2>
<p>– <strong>Slide so Easy</strong> (1) har fått det bästa startspåret. Det blir att köra vad det går hela vägen i ryggar. Är han fyra-femma har han gjort det väldigt bra. Jag tar ut bomullen ur öronen nu, annars går han precis som han brukar, säger Flemming Jensen.<br />
– <strong>Perfect Spirit</strong> (2) svarade för en märklig insats senast, men vi hittade inga fel och han hade inte överdrivet hög puls. Ganska direkt i jobben efteråt var han lika fin som inför det loppet. Han hade dessutom lyft sig i jobben inför loppet senast. Vi måste tro att han är bra igen. Ska vi gissa på något kan det varit banan som gjorde honom hovöm. Läget är perfekt och han är snabb, säger Daniel Redén.<br />
– <strong>Ringostarr Treb</strong> (3) kommer med toppform och allt är väl med honom. Nu blir det jänkarvagn igen efter att ha tävlat i vanlig sulky i årets två starter. Han är snabb iväg och kan nog hålla upp ledningen om Paal vill, men han är inte beroende av att gå där och sitt rekord har han satt bakifrån. Paal får bestämma taktik utifrån hur det känns på söndag och vi åker så att vi är framme på lördagkväll efter att de har tävlat klart på Bjerke, säger Jerry Riordan.<br />
– <strong>Vitruvio</strong> (4) kom till Balltorp i Mölndal i tisdagskväll och jag körde fort själv med honom i torsdags. Jag tror att han åker till Oslo lördag morgon och han tävlar barfota runt om som han brukar göra i större lopp. Senast var det en häst som trampade upp i hans hjul så han sprang med punktering hela loppet, därav resultatet, säger Alessandro Gocciadoro.</p>
<figure id="attachment_42526" aria-describedby="caption-attachment-42526" style="width: 617px" class="wp-caption alignright"><img class="size-sulky-mellan2 wp-image-42526" src="https://sulkysport.se/wp-content/uploads/2019/04/bahiaquesnot-617x393.jpg" alt="" width="617" height="393" /><figcaption id="caption-attachment-42526" class="wp-caption-text">Bahia Quesnot och Junior Guelpa ska starta i Oslo Grand Prix. Foto: Simon Hagen</figcaption></figure>
<p>– <strong>Bahia Quesnot</strong> (5) är bättre över 2.100 meter än 1.600 meter och kommer gåbra till slut. Jag tror att hon kommer vara med bland de tre främsta och nu ska hon tävla barfota igen, säger Gerard Forni.<br />
– <strong>Gretzky B.R.</strong> (6) har gjort allt rätt i år. Det är stentufft motstånd, men det är trots allt hemmaplan och då känns det kul att testa. Hästen tränar fint och är startsnabb. Jag hoppas på en bra position, men är nöjd med en bra premie, säger Geir Vegard Gundersen.<br />
– <strong>Valokaja Hindö</strong> (7) tränade på ett fantastiskt vis under söndagen, men nu går han upp i klass. Man vet aldrig med Bazire, men jag tror att han får nöja sig med en bra prispeng nu. Hästen kommer tävla barfota, säger Gerard Forni.<br />
– <strong>Uza Josselyn</strong> (8) kom inte in i loppet på Solvalla. Hon kommer vara bättre nu och 2.100 meter är perfekt. Hon kommer spurta starkt och vara bland de tre främsta, ja hon kan rentav vinna loppet. Kusken är dessutom i form, säger Gerard Forni.<br />
– <strong>Nadal Broline</strong> (9) har Björn siktat mot det här loppet med efter Solvallasegern och Elitloppet var aldrig något riktigt alternativ. Hästen är inget träningslejon, men visar allt väl i träningen. Niondespår är okej och får han spara speeden gör han upp om tätplatserna, säger Anton Sverre i Björn Goops stall.</p>
